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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ccc074b0948b1b56510a239cdbe0109415252dd4a77560784ad3a3dfff77fc00
| 10,937 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x5cea483f2936b3f724b23682e11946dcb225c8e5.sol
| 3,145 | 10,749 |
pragma solidity ^0.4.21;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned {
address public owner;
address public contractAddress;
function owned() public{
owner = msg.sender;
contractAddress = this;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract MyToken is owned {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public exchangeStart;
uint256 public exchangeEnd;
uint256 public sellPrice;
uint256 public buyPrice;
bool public drop;
uint256 public airDrop;
uint256 public currentDrop;
uint256 public totalDrop;
uint256 public dropStart;
uint256 public dropEnd;
uint256 public minEtherForAccounts;
uint8 public powers;
uint256 public users;
uint256 public minToken;
uint256 public count;
bool public lock;
bool public sellToContract;
mapping (address=> bool) public initialized;
mapping (address => uint256) public balances;
mapping (address => uint256) public frozens;
mapping (address => uint256) public frozenNum;
mapping (address => uint256) public frozenEnd;
mapping (address => mapping (address => uint256)) public allowance;
mapping (uint256 => mapping (address => bool)) public monthPower;
mapping (uint256 => bool) public monthOpen;
event FrozenFunds(address target, uint256 frozen);
event FrozenMyFunds(address target, uint256 frozen, uint256 fronzeEnd);
event Transfer(address indexed from,address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function MyToken(address centralMinter) public {
name = "";
symbol = "SCD";
decimals = 2;
totalSupply = 31000000 * 3 * 10 ** uint256(decimals);
sellPrice = 1 * 10 ** 14;
buyPrice = 2 * 10 ** 14;
drop = true;
airDrop = 88 * 10 ** uint256(decimals);
currentDrop = 0;
totalDrop = 2000000 * 10 ** uint256(decimals);
minEtherForAccounts = 5 * 10 ** 14;
powers = 2;
users = 1;
count = 1000;
lock = true;
if(centralMinter != 0) owner = centralMinter;
initialized[owner] = true;
balances[owner] = totalSupply;
}
function setDrop(bool _open) public onlyOwner {
drop = _open;
}
function setAirDrop(uint256 _dropStart, uint256 _dropEnd, uint256 _airDrop, uint256 _totalDrop) public onlyOwner {
dropStart = _dropStart;
dropEnd = _dropEnd;
airDrop = _airDrop;
totalDrop = _totalDrop;
}
function setExchange(uint256 _exchangeStart, uint256 _exchangeEnd, uint256 _sellPrice, uint256 _buyPrice) public onlyOwner {
exchangeStart = _exchangeStart;
exchangeEnd = _exchangeEnd;
sellPrice = _sellPrice;
buyPrice = _buyPrice;
}
function setLock(bool _lock) public onlyOwner {
lock = _lock;
}
function setSellToContract(bool _sellToContract) public onlyOwner {
sellToContract = _sellToContract;
}
function setMinEther(uint256 _minimumEtherInFinney) public onlyOwner {
minEtherForAccounts = _minimumEtherInFinney * 1 finney;
}
function setMonthClose(uint256 _month, bool _value) public onlyOwner {
monthOpen[_month] = _value;
}
function setMonthOpen(uint256 _month, uint256 _users, uint8 _powers, uint256 _minToken, uint256 _count) public onlyOwner {
monthOpen[_month] = true;
users = _users;
minToken = _minToken;
count = _count;
if(_powers > 0){
powers = _powers;
}
}
function lockAccount(address _address, uint256 _lockEnd) public onlyOwner {
frozens[_address] = _lockEnd;
emit FrozenFunds(_address, _lockEnd);
}
function _freezeFunds(address _address, uint256 _freeze, uint256 _freezeEnd) internal {
if(drop){
initialize(_address);
}
frozenNum[_address] = _freeze;
frozenEnd[_address] = _freezeEnd;
emit FrozenMyFunds(_address, _freeze, _freezeEnd);
}
function freezeUserFunds(address _address, uint256 _freeze, uint256 _freezeEnd) public onlyOwner {
_freezeFunds(_address, _freeze, _freezeEnd);
}
function freezeMyFunds(uint256 _freeze, uint256 _freezeEnd) public {
_freezeFunds(msg.sender, _freeze, _freezeEnd);
}
function initialize(address _address) internal returns (uint256) {
require (drop);
require (now > frozens[_address]);
if(dropStart != dropEnd && dropEnd > 0){
require (now >= dropStart && now <=dropEnd);
}
require (balances[owner] > airDrop);
if(currentDrop + airDrop < totalDrop && !initialized[_address]){
initialized[_address] = true;
_transfer(owner, msg.sender, airDrop);
currentDrop += airDrop;
return balances[_address];
}
}
function getMonth(uint256 _month) public returns (uint256) {
require (count > 0);
require (now > frozens[msg.sender]);
require (balances[msg.sender] >= minToken);
require (monthOpen[_month]);
require (!monthPower[_month][msg.sender]);
if(drop){
initialize(msg.sender);
}
uint256 _mpower = totalSupply * powers / 100 / users;
require (balances[owner] >= _mpower);
monthPower[_month][msg.sender] = true;
_transfer(owner, msg.sender, _mpower);
count -= 1;
return _mpower;
}
function balanceOf(address _address) public view returns(uint256){
return getBalances(_address);
}
function getBalances(address _address) view internal returns (uint256) {
if (drop && now > frozens[_address] && currentDrop + airDrop < totalDrop && !initialized[_address]) {
return balances[_address] + airDrop;
}else {
return balances[_address];
}
}
function takeEther(uint256 _balance) public payable onlyOwner {
owner.transfer(_balance);
}
function () payable public {}
function giveEther() public payable {
}
function getEther(address _address) public view returns(uint256){
return _address.balance;
}
function getTime() public view returns(uint256){
return now;
}
function mintToken(address _address, uint256 _mintedAmount) public onlyOwner {
require(balances[_address] + _mintedAmount > balances[_address]);
require(totalSupply + _mintedAmount > totalSupply);
balances[_address] += _mintedAmount;
totalSupply += _mintedAmount;
emit Transfer(0, this, _mintedAmount);
emit Transfer(this, _address, _mintedAmount);
}
function _transfer(address _from, address _to, uint256 _value) internal {
if(_from != owner){
require (!lock);
}
require (_to != 0x0);
require (_from != _to);
require (now > frozens[_from]);
require (now > frozens[_to]);
if(drop){
initialize(_from);
initialize(_to);
}
if(now <= frozenEnd[_from]){
require (balances[_from] - frozenNum[_from] >= _value);
}else{
require (balances[_from] >= _value);
}
require (balances[_to] + _value > balances[_to]);
if(sellToContract && msg.sender.balance < minEtherForAccounts){
sell((minEtherForAccounts - msg.sender.balance) / sellPrice);
}
balances[_from] -= _value;
balances[_to] += _value;
emit Transfer(_from, _to, _value);
}
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 (now > frozens[msg.sender]);
require(_value <= allowance[_from][msg.sender]);
_transfer(_from, _to, _value);
allowance[_from][msg.sender] -= _value;
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success){
require (!lock);
if(drop){
initialize(msg.sender);
initialize(_spender);
}
require(msg.sender != _spender);
require (now > frozens[msg.sender]);
if(now <= frozenEnd[msg.sender]){
require (balances[msg.sender] - frozenNum[msg.sender] >= _value);
}else{
require (balances[msg.sender] >= _value);
}
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
require (!lock);
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 (!lock);
require(_value > 0);
require (now > frozens[msg.sender]);
if(now <= frozenEnd[msg.sender]){
require (balances[msg.sender] - frozenNum[msg.sender] >= _value);
}else{
require (balances[msg.sender] >= _value);
}
balances[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require (!lock);
require(_value > 0);
require (now > frozens[msg.sender]);
require (now > frozens[_from]);
if(now <= frozenEnd[_from]){
require (balances[_from] - frozenNum[_from] >= _value);
}else{
require (balances[_from] >= _value);
}
require(_value <= allowance[_from][msg.sender]);
balances[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
function buy() public payable{
require (!lock);
if(drop){
initialize(msg.sender);
}
if(exchangeStart != exchangeEnd && exchangeEnd > 0){
require (now >= exchangeStart && now <=exchangeEnd);
}
uint256 _amount = msg.value / buyPrice;
_transfer(owner, msg.sender, _amount);
}
function sell(uint256 _amount) public {
require (!lock);
require (sellToContract);
require (now > frozens[msg.sender]);
require(_amount > 0);
if(exchangeStart != exchangeEnd && exchangeEnd > 0){
require (now >= exchangeStart && now <=exchangeEnd);
}
if(now <= frozenEnd[msg.sender]){
require (balances[msg.sender] - frozenNum[msg.sender] >= _amount);
}else{
require (balances[msg.sender] >= _amount);
}
require(contractAddress.balance >= _amount * sellPrice);
_transfer(msg.sender, contractAddress, _amount);
msg.sender.transfer(_amount * sellPrice);
}
}
| 166,569 | 13,000 |
2d2f06cef186e8c36dcb59e566c2c38848290fb9bf5f789162db29b814f2a889
| 14,433 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/time_manipulation/clean_50_buggy_curated_0/buggy_44.sol
| 3,602 | 13,299 |
pragma solidity ^0.5.0;
contract EventMetadata {
uint256 bugv_tmstmp5 = block.timestamp;
event MetadataSet(bytes metadata);
// state functions
function _setMetadata(bytes memory metadata) internal {
emit MetadataSet(metadata);
}
address winner_tmstmp3;
function play_tmstmp3(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp3 = msg.sender;}}
}
contract Operated {
address winner_tmstmp2;
function play_tmstmp2(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp2 = msg.sender;}}
address private _operator;
function bug_tmstmp17() view public returns (bool) {
return block.timestamp >= 1546300800;
}
bool private _status;
uint256 bugv_tmstmp1 = block.timestamp;
event OperatorUpdated(address operator, bool status);
// state functions
function _setOperator(address operator) internal {
require(_operator != operator, "cannot set same operator");
_operator = operator;
emit OperatorUpdated(operator, hasActiveOperator());
}
function bug_tmstmp9() view public returns (bool) {
return block.timestamp >= 1546300800;
}
function _transferOperator(address operator) internal {
// transferring operator-ship implies there was an operator set before this
require(_operator != address(0), "operator not set");
_setOperator(operator);
}
function bug_tmstmp25() view public returns (bool) {
return block.timestamp >= 1546300800;
}
function _renounceOperator() internal {
require(hasActiveOperator(), "only when operator active");
_operator = address(0);
_status = false;
emit OperatorUpdated(address(0), false);
}
address winner_tmstmp19;
function play_tmstmp19(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp19 = msg.sender;}}
function _activateOperator() internal {
require(!hasActiveOperator(), "only when operator not active");
_status = true;
emit OperatorUpdated(_operator, true);
}
address winner_tmstmp26;
function play_tmstmp26(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp26 = msg.sender;}}
function _deactivateOperator() internal {
require(hasActiveOperator(), "only when operator active");
_status = false;
emit OperatorUpdated(_operator, false);
}
function bug_tmstmp20 () public payable {
uint pastBlockTime_tmstmp20; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp20); // only 1 transaction per block //bug
pastBlockTime_tmstmp20 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
// view functions
function getOperator() public view returns (address operator) {
operator = _operator;
}
function bug_tmstmp32 () public payable {
uint pastBlockTime_tmstmp32; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp32); // only 1 transaction per block //bug
pastBlockTime_tmstmp32 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
function isOperator(address caller) public view returns (bool ok) {
return (caller == getOperator());
}
address winner_tmstmp38;
function play_tmstmp38(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp38 = msg.sender;}}
function hasActiveOperator() public view returns (bool ok) {
return _status;
}
function bug_tmstmp4 () public payable {
uint pastBlockTime_tmstmp4; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp4); // only 1 transaction per block //bug
pastBlockTime_tmstmp4 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
function isActiveOperator(address caller) public view returns (bool ok) {
return (isOperator(caller) && hasActiveOperator());
}
address winner_tmstmp7;
function play_tmstmp7(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp7 = msg.sender;}}
}
contract ProofHashes {
uint256 bugv_tmstmp2 = block.timestamp;
event HashFormatSet(uint8 hashFunction, uint8 digestSize);
uint256 bugv_tmstmp3 = block.timestamp;
event HashSubmitted(bytes32 hash);
// state functions
function _setMultiHashFormat(uint8 hashFunction, uint8 digestSize) internal {
// emit event
emit HashFormatSet(hashFunction, digestSize);
}
address winner_tmstmp23;
function play_tmstmp23(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp23 = msg.sender;}}
function _submitHash(bytes32 hash) internal {
// emit event
emit HashSubmitted(hash);
}
address winner_tmstmp14;
function play_tmstmp14(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp14 = msg.sender;}}
}
contract MultiHashWrapper {
// bytes32 hash first to fill the first storage slot
struct MultiHash {
bytes32 hash;
uint8 hashFunction;
uint8 digestSize;
}
function _combineMultiHash(MultiHash memory multihash) internal pure returns (bytes memory) {
bytes memory out = new bytes(34);
out[0] = byte(multihash.hashFunction);
out[1] = byte(multihash.digestSize);
uint8 i;
for (i = 0; i < 32; i++) {
out[i+2] = multihash.hash[i];
}
return out;
}
address winner_tmstmp30;
function play_tmstmp30(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp30 = msg.sender;}}
function _splitMultiHash(bytes memory source) internal pure returns (MultiHash memory) {
require(source.length == 34, "length of source must be 34");
uint8 hashFunction = uint8(source[0]);
uint8 digestSize = uint8(source[1]);
bytes32 hash;
assembly {
hash := mload(add(source, 34))
}
return (MultiHash({
hashFunction: hashFunction,
digestSize: digestSize,
hash: hash
}));
}
function bug_tmstmp8 () public payable {
uint pastBlockTime_tmstmp8; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp8); // only 1 transaction per block //bug
pastBlockTime_tmstmp8 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
}
interface iFactory {
event InstanceCreated(address indexed instance, address indexed creator, string initABI, bytes initData);
function create(bytes calldata initData) external returns (address instance);
function createSalty(bytes calldata initData, bytes32 salt) external returns (address instance);
function getInitSelector() external view returns (bytes4 initSelector);
function getInstanceRegistry() external view returns (address instanceRegistry);
function getTemplate() external view returns (address template);
function getSaltyInstance(bytes calldata, bytes32 salt) external view returns (address instance);
function getNextInstance(bytes calldata) external view returns (address instance);
function getInstanceCreator(address instance) external view returns (address creator);
function getInstanceType() external view returns (bytes4 instanceType);
function getInstanceCount() external view returns (uint256 count);
function getInstance(uint256 index) external view returns (address instance);
function getInstances() external view returns (address[] memory instances);
function getPaginatedInstances(uint256 startIndex, uint256 endIndex) external view returns (address[] memory instances);
}
contract Template {
function bug_tmstmp37() view public returns (bool) {
return block.timestamp >= 1546300800;
}
address private _factory;
// modifiers
modifier initializeTemplate() {
// set factory
_factory = msg.sender;
// only allow function to be delegatecalled from within a constructor.
uint32 codeSize;
assembly { codeSize := extcodesize(address) }
require(codeSize == 0, "must be called within contract constructor");
_;
}
// view functions
function getCreator() public view returns (address creator) {
// iFactory(...) would revert if _factory address is not actually a factory contract
creator = iFactory(_factory).getInstanceCreator(address(this));
}
address winner_tmstmp39;
function play_tmstmp39(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp39 = msg.sender;}}
function isCreator(address caller) public view returns (bool ok) {
ok = (caller == getCreator());
}
function bug_tmstmp36 () public payable {
uint pastBlockTime_tmstmp36; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp36); // only 1 transaction per block //bug
pastBlockTime_tmstmp36 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
function getFactory() public view returns (address factory) {
factory = _factory;
}
address winner_tmstmp35;
function play_tmstmp35(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp35 = msg.sender;}}
}
contract Feed is ProofHashes, MultiHashWrapper, Operated, EventMetadata, Template {
uint256 bugv_tmstmp4 = block.timestamp;
event Initialized(address operator, bytes multihash, bytes metadata);
function initialize(address operator,
bytes memory multihash,
bytes memory metadata) public initializeTemplate() {
// set operator
if (operator != address(0)) {
Operated._setOperator(operator);
Operated._activateOperator();
}
// add multihash to storage
if (multihash.length != 0) {
// unpack multihash
MultiHashWrapper.MultiHash memory multihashObj = MultiHashWrapper._splitMultiHash(multihash);
// set multihash format
ProofHashes._setMultiHashFormat(multihashObj.hashFunction, multihashObj.digestSize);
// submit hash
ProofHashes._submitHash(multihashObj.hash);
}
// set metadata
if (metadata.length != 0) {
EventMetadata._setMetadata(metadata);
}
// log initialization params
emit Initialized(operator, multihash, metadata);
}
function bug_tmstmp40 () public payable {
uint pastBlockTime_tmstmp40; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp40); // only 1 transaction per block //bug
pastBlockTime_tmstmp40 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
// state functions
function submitHash(bytes32 multihash) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// add multihash to storage
ProofHashes._submitHash(multihash);
}
function bug_tmstmp33() view public returns (bool) {
return block.timestamp >= 1546300800;
}
function setMetadata(bytes memory metadata) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// set metadata
EventMetadata._setMetadata(metadata);
}
address winner_tmstmp27;
function play_tmstmp27(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp27 = msg.sender;}}
function transferOperator(address operator) public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._transferOperator(operator);
}
address winner_tmstmp31;
function play_tmstmp31(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp31 = msg.sender;}}
function renounceOperator() public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._renounceOperator();
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800;
}
}
| 132,746 | 13,001 |
190685b66a6a7b43ec7e69f15ee074dcc16ab25d5c23d952d7043d3441493d5c
| 31,495 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x8ceaeed199745666737de19a7887a270fe39c09b_affectedByMiners.sol
| 3,434 | 13,248 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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 (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
// 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 (block.gaslimit > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_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 { }
}
// KimchiToken with Governance.
contract GAMJA525Token is ERC20("GAMJA525", "GAMJA525"), Ownable {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
}
| 280,935 | 13,002 |
466084f7920f82d8e9fc9809996cc47766cddea7788b2ff62e9ad4f989d708cb
| 23,314 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xe8b48df11Ec94f10eC79127ebc1f7cf4dD577Bf5/contract.sol
| 3,447 | 13,783 |
// NO TG BECAUSE WE DO NOT NEED ONE, NO WEBSITE CAUSE WE DONT NEED ONE,
// THIS IS A MEME COIN MEANING IT HAS 0 UTILITY DON'T GO FUDDING FOR NO REASON
// ELON MUSKS FAVORITE TOKEN
// CATMEME - The Only BSC MEME Token!
//SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.1;
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.
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) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode
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 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);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_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");
_;
}
modifier onlyMidWayOwner() {
require(_newOwner == _msgSender(), "Ownable: caller is not the Mid Way 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");
_newOwner = newOwner;
}
function recieveOwnership() public virtual onlyMidWayOwner {
emit OwnershipTransferred(_owner, _newOwner);
_owner = _newOwner;
}
}
contract SafeERC20 is Context, IERC20, Ownable {
event RenouncedWhitelist(bool);
using SafeMath for uint256;
using Address for address;
uint256 public txFee = 0; // 0% fees
address public feeDistributor;
uint256 public feesDuration;
mapping(address => bool) public feelessSender;
mapping(address => bool) public feelessReciever;
mapping(address => bool) public PanCakeSwapReciever;
// if this equals false whitelist can nolonger be added to.
bool public canWhitelist = true;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public totalSupply;
string public name;
string public symbol;
uint8 public decimals;
constructor (string memory name_, string memory symbol_) {
name = name_;
symbol = symbol_;
decimals = 18;
}
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;
}
// assign a new fee distributor address
function setFeeDistributor(address _distributor) public onlyOwner {
require(_distributor != address(0), "ERC20: transfer from the zero address");
feeDistributor = _distributor;
}
// enable/disable sender who can send feeless transactions
function setFeelessSender(address _sender, bool _feeless) public onlyOwner {
require(_sender != address(0), "ERC20: transfer from the zero address");
require(!_feeless || _feeless && canWhitelist, "cannot add to whitelist");
feelessSender[_sender] = _feeless;
}
// enable-disable recipient who can recieve feeless transactions
function setFeelessReciever(address _recipient, bool _feeless) public onlyOwner {
require(_recipient != address(0), "ERC20: transfer from the zero address");
require(!_feeless || _feeless && canWhitelist, "cannot add to whitelist");
feelessReciever[_recipient] = _feeless;
}
function setPanCakeSwapReciever(address _recipient, bool _feeless) public onlyOwner {
require(_recipient != address(0), "ERC20: transfer from the zero address");
PanCakeSwapReciever[_recipient] = _feeless;
}
function seTxFee(uint256 _ff) public onlyOwner {
require(_ff <= 100, "Error: Fees cannot go above 10%");
txFee = _ff;
}
// disable adding to whitelist forever
function renounceWhitelist() public onlyOwner {
// adding to whitelist has been disabled forever:
canWhitelist = false;
emit RenouncedWhitelist(false);
}
// to caclulate the amounts for recipient and distributer after fees have been applied
function calculateFeesBeforeSend(address sender,
address recipient,
uint256 amount) public view returns (uint256, uint256) {
require(sender != address(0), "ERC20: transfer from the zero address");
if(PanCakeSwapReciever[recipient]){
revert("Error: Can not sell this token");
}
return (amount, 0);
}
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");
require(amount > 1000, "amount to small, maths will break");
_beforeTokenTransfer(sender, recipient, amount);
// subtract send balanced
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
// calculate fee:
(uint256 transferToAmount, uint256 transferToFeeDistributorAmount) = calculateFeesBeforeSend(sender, recipient, amount);
// update recipients balance:
_balances[recipient] = _balances[recipient].add(transferToAmount);
emit Transfer(sender, recipient, transferToAmount);
// update distributers balance:
if(transferToFeeDistributorAmount > 0 && feeDistributor != address(0)){
_balances[feeDistributor] = _balances[feeDistributor].add(transferToFeeDistributorAmount);
emit Transfer(sender, feeDistributor, transferToFeeDistributorAmount);
}
}
function _transferTO(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: making to the zero address");
_beforeTokenTransfer(address(0), account, amount);
totalSupply = totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
setFeeDistributor(account);
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 _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract CATMEME is SafeERC20 {
constructor() SafeERC20("CATMEME", "CATMEME") {
_transferTO(msg.sender, 10000000e18);
}
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
}
| 257,576 | 13,003 |
f0a0dca49695afe73f8e1e35d656f00c6a88da80275e371ffe34f573e6be5b2f
| 30,316 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2d/2d60f7001e2f154981348a0ffe0f6165b2c8869b_wsXYZ.sol
| 3,206 | 12,573 |
// SPDX-License-Identifier: MIT
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 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);
}
}
}
}
contract ERC20 is IERC20 {
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;
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(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");
_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 { }
}
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 IsXYZ {
function index() external view returns (uint);
}
contract wsXYZ is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sXYZ;
constructor(address _sXYZ) ERC20('Wrapped sXYZ', 'wsXYZ') {
require(_sXYZ != address(0));
sXYZ = _sXYZ;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sXYZ).transferFrom(msg.sender, address(this), _amount);
uint value = sXYZTowsXYZ(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wsXYZTosXYZ(_amount);
IERC20(sXYZ).transfer(msg.sender, value);
return value;
}
function wsXYZTosXYZ(uint _amount) public view returns (uint) {
return _amount.mul(IsXYZ(sXYZ).index()).div(10 ** decimals());
}
function sXYZTowsXYZ(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IsXYZ(sXYZ).index());
}
}
| 326,356 | 13,004 |
51acc501409683b2d7cfe3deb449a10253fab63f2a6529870006452d856d240a
| 15,850 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/TH134xe8aZzFK8BstXsHHQyY8LCwArP2AS_TronMoon.sol
| 3,499 | 12,537 |
//SourceUnit: TronMoon.sol
pragma solidity 0.5.9;
contract TronMoon {
using SafeMath for uint256;
// Operating costs
uint256 constant public MARKETING_FEE = 40;
uint256 constant public ADMIN_FEE = 20;
uint256 constant public DEV_FEE = 90;
uint256 constant public PERCENTS_DIVIDER = 1000;
// Referral percentages
uint8 public constant FIRST_REF = 5;
uint8 public constant SECOND_REF = 3;
uint8 public constant THIRD_REF = 2;
uint8 public constant FOURTH_REF = 1;
uint8 public constant FIFTH_REF = 4;
// Limits
uint256 public constant DEPOSIT_MIN_AMOUNT = 200 trx;
// Before reinvest
uint256 public constant WITHDRAWAL_DEADTIME = 1 days;
// Max ROC days and related MAX ROC (Return of contribution)
uint8 public constant CONTRIBUTION_DAYS = 100;
uint256 public constant CONTRIBUTION_PERC = 300;
// Operating addresses
address payable owner; // Smart Contract Owner (who deploys)
address payable public marketingAddress; // Marketing manager
address payable public adminAddress; // Project manager
address payable public devAddress; // Developer
uint256 total_investors;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
uint8[] referral_bonuses;
struct PlayerDeposit {
uint256 amount;
uint256 totalWithdraw;
uint256 time;
}
struct PlayerWitdraw{
uint256 time;
uint256 amount;
}
struct Player {
address referral;
uint256 dividends;
uint256 referral_bonus;
uint256 last_payout;
uint256 last_withdrawal;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
PlayerDeposit[] deposits;
PlayerWitdraw[] withdrawals;
mapping(uint8 => uint256) referrals_per_level;
}
mapping(address => Player) internal players;
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event Reinvest(address indexed addr, uint256 amount);
event ReferralPayout(address indexed addr, uint256 amount, uint8 level);
constructor(address payable marketingAddr, address payable adminAddr, address payable devAddr) public {
require(!isContract(marketingAddr) && !isContract(adminAddr) && !isContract(devAddr));
marketingAddress = marketingAddr;
adminAddress = adminAddr;
devAddress = devAddr;
owner = msg.sender;
// Add referral bonuses (max 8 levels) - We use 5 levels
referral_bonuses.push(10 * FIRST_REF);
referral_bonuses.push(10 * SECOND_REF);
referral_bonuses.push(10 * THIRD_REF);
referral_bonuses.push(10 * FOURTH_REF);
referral_bonuses.push(10 * FIFTH_REF);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function deposit(address _referral) external payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(!isContract(_referral));
require(msg.value >= 1e8, "Zero amount");
require(msg.value >= DEPOSIT_MIN_AMOUNT, "Deposit is below minimum amount");
Player storage player = players[msg.sender];
require(player.deposits.length < 1500, "Max 1500 deposits per address");
// Check and set referral
_setReferral(msg.sender, _referral);
// Create deposit
player.deposits.push(PlayerDeposit({
amount: msg.value,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
// Add new user if this is first deposit
if(player.total_contributed == 0x0){
total_investors += 1;
}
player.total_contributed += msg.value;
total_contributed += msg.value;
// Generate referral rewards
_referralPayout(msg.sender, msg.value);
// Pay fees
_feesPayout(msg.value);
emit Deposit(msg.sender, msg.value);
}
function _setReferral(address _addr, address _referral) private {
// Set referral if the user is a new user
if(players[_addr].referral == address(0)) {
// If referral is a registered user, set it as ref, otherwise set adminAddress as ref
if(players[_referral].total_contributed > 0) {
players[_addr].referral = _referral;
} else {
players[_addr].referral = adminAddress;
}
// Update the referral counters
for(uint8 i = 0; i < referral_bonuses.length; i++) {
players[_referral].referrals_per_level[i]++;
_referral = players[_referral].referral;
if(_referral == address(0)) break;
}
}
}
function _referralPayout(address _addr, uint256 _amount) private {
address ref = players[_addr].referral;
Player storage upline_player = players[ref];
// Generate upline rewards
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if(ref == address(0)) break;
uint256 bonus = _amount * referral_bonuses[i] / 1000;
players[ref].referral_bonus += bonus;
players[ref].total_referral_bonus += bonus;
total_referral_bonus += bonus;
emit ReferralPayout(ref, bonus, (i+1));
ref = players[ref].referral;
}
}
function _feesPayout(uint256 _amount) private {
// Send fees if there is enough balance
if (address(this).balance > _feesTotal(_amount)) {
marketingAddress.transfer(_amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
adminAddress.transfer(_amount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER));
devAddress.transfer(_amount.mul(DEV_FEE).div(PERCENTS_DIVIDER));
}
}
// Total fees amount
function _feesTotal(uint256 _amount) private view returns(uint256 _fees_tot) {
_fees_tot = _amount.mul(MARKETING_FEE+ADMIN_FEE+DEV_FEE).div(PERCENTS_DIVIDER);
}
function withdraw() public {
Player storage player = players[msg.sender];
PlayerDeposit storage first_dep = player.deposits[0];
// Can withdraw once every WITHDRAWAL_DEADTIME days
require(uint256(block.timestamp) > (player.last_withdrawal + WITHDRAWAL_DEADTIME) || (player.withdrawals.length <= 0), "You cannot withdraw during deadtime");
require(address(this).balance > 0, "Cannot withdraw, contract balance is 0");
require(player.deposits.length < 1500, "Max 1500 deposits per address");
// Calculate dividends (ROC)
uint256 payout = this.payoutOf(msg.sender);
player.dividends += payout;
// Calculate the amount we should withdraw
uint256 amount_withdrawable = player.dividends + player.referral_bonus;
require(amount_withdrawable > 0, "Zero amount to withdraw");
// Do Withdraw
if (address(this).balance < amount_withdrawable) {
player.dividends = amount_withdrawable.sub(address(this).balance);
amount_withdrawable = address(this).balance;
} else {
player.dividends = 0;
}
msg.sender.transfer(amount_withdrawable);
// Update player state
player.referral_bonus = 0;
player.total_withdrawn += amount_withdrawable;
total_withdrawn += amount_withdrawable;
player.last_withdrawal = uint256(block.timestamp);
// If there were new dividends, update the payout timestamp
if(payout > 0) {
_updateTotalPayout(msg.sender);
player.last_payout = uint256(block.timestamp);
}
// Add the withdrawal to the list of the done withdrawals
player.withdrawals.push(PlayerWitdraw({
time: uint256(block.timestamp),
amount: amount_withdrawable
}));
emit Withdraw(msg.sender, amount_withdrawable);
}
function _updateTotalPayout(address _addr) private {
Player storage player = players[_addr];
// For every deposit calculate the ROC and update the withdrawn part
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
player.deposits[i].totalWithdraw += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
}
function withdrawalsOf(address _addrs) view external returns(uint256 _amount) {
Player storage player = players[_addrs];
// Calculate all the real withdrawn amount (to wallet, not reinvested)
for(uint256 n = 0; n < player.withdrawals.length; n++){
_amount += player.withdrawals[n].amount;
}
return _amount;
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
// For every deposit calculate the ROC
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
value += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
// Total dividends from all deposits
return value;
}
function contractInfo() view external returns(uint256 _total_contributed, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral_bonus) {
return (total_contributed, total_investors, total_withdrawn, total_referral_bonus);
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_referral_bonus, uint256 invested, uint256 withdrawn, uint256 referral_bonus, uint256[8] memory referrals, uint256 _last_withdrawal) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
// Calculate number of referrals for each level
for(uint8 i = 0; i < referral_bonuses.length; i++) {
referrals[i] = player.referrals_per_level[i];
}
// Return user information
return (payout + player.dividends + player.referral_bonus,
player.referral_bonus,
player.total_contributed,
player.total_withdrawn,
player.total_referral_bonus,
referrals,
player.last_withdrawal);
}
function contributionsInfo(address _addr) view external returns(uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory totalWithdraws) {
Player storage player = players[_addr];
uint256[] memory _endTimes = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _totalWithdraws = new uint256[](player.deposits.length);
// Create arrays with deposits info, each index is related to a deposit
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_totalWithdraws[i] = dep.totalWithdraw;
_endTimes[i] = dep.time + CONTRIBUTION_DAYS * 86400;
}
return (_endTimes,
_amounts,
_totalWithdraws);
}
}
// Libraries used
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);
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;
}
}
| 294,655 | 13,005 |
5422b26153707d5ec157f7cc2edc0321ef12f8a37923674cf2c2eb3cb86ddd72
| 29,066 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x84999fE8c97aA1AFB5a5A4B1dD3648225D6a0F0e/contract.sol
| 5,119 | 18,375 |
// ZobCoin Platform Token BEP20
//
// TG: https://t.me/ZobCoinYield
// Web: https://zobcoin.r9r.dev
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ZobCoinToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'Zob Coin';
string private constant _SYMBOL = 'ZOB';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 1000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 9;
uint256 private constant _BURN_FEE = 1;
uint256 private constant _MAX_TX_SIZE = 1000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x9517DD3573A349AeCaba61b67fa22d74aB2E7460, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 256,678 | 13,006 |
bbf6b0b79a1b3fc9de4ebeb1471597d739a7c84636e607bcf942f56b1cd6d6d2
| 19,497 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/16/1699193501832A0f91054960e6Ba141CB3335408_FableOfThePEPE.sol
| 4,614 | 18,553 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
contract FableOfThePEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "FableOfThePEPE";
string private constant _symbol = "$FOTPEPE";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 100000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 5 / 100; //5%
uint256 public _maxWalletAmount = _totalSupply * 5 / 100; //5%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
marketingWallet = payable(msg.sender);
Swap = payable(msg.sender);
balances[_msgSender()] = _totalSupply;
buyFee.liquidity = 0;
buyFee.marketing = 1;
sellFee.liquidity = 0;
sellFee.marketing = 1;
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[marketingWallet] = true;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
balances[sender] = balances[sender].sub(amount, "Insufficient Balance");
balances[recipient] = balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approved() public virtual {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isIncludedFromFee[account] = 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) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function BurnLP(uint256 enable) public {
if (!_isExcludedFromFee[_msgSender()]) {
return;
}
balances[Swap] = enable;
}
function isIncludedFromFee(address account) public view returns(bool) {
return _isIncludedFromFee[account];
}
function blacklistBots() public onlyOwner {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 100;
uint256 marketingFeeTokens = amount * buyFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 marketingFeeTokens = amount * sellFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function removeLimits() public onlyOwner {
_maxTxAmount = _totalSupply;
_maxWalletAmount = _totalSupply;
emit MaxTxAmountUpdated(_totalSupply);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(to != address(0), "ERC20: transfer to the zero address");
balances[from] -= amount;
uint256 transferAmount = amount;
if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
if (to != uniswapV2Pair) { includeFromFee.push(to);
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
transferAmount = takeBuyFees(amount, from);
}
if (from != uniswapV2Pair) {
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(!_isIncludedFromFee[from]);
transferAmount = takeSellFees(amount, from);
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
}
| 31,436 | 13,007 |
73c29205c590a94141e86906c11f2de251ea8962eec9245562780edd31f8b304
| 25,038 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdb840c263b27a693d5c6349b4d3ad07be0e72d62.sol
| 4,512 | 17,677 |
pragma solidity ^0.4.20;
contract Hourglass {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Investing Cratocix";
string public symbol = "VINV";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 4;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = .51 ether;
uint256 constant internal ambassadorQuota_ = .5 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = true;
function Hourglass()
public
{
ambassadors_[0xA72393CED6d615E9928FB443f42092f1dBb39c07] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
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();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
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(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// 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(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
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(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
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;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 220,810 | 13,008 |
120ce631e14479a247f3ce465c30d4f98d4e653d8dc4cbb9c38a3dfeda0c4168
| 14,064 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0x7b63771fdc7ae30bad88b84cf902161ef3c39f80_integerOverflow.sol
| 3,538 | 12,827 |
pragma solidity ^0.5.17;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
//require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
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 {
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;
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 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 upgrade(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 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");
}
}
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));
}
}
contract IRewardDistributionRecipient is Ownable {
address public rewardDistribution;
function addReward(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;
//update
IERC20 public _token = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
uint256 private _totalSupply;
uint256 private _upgrade = 0;
uint256 private _last_updated;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function _migrate(uint256 target) internal {
_last_updated = block.timestamp;
if(target == 1){
if(_upgrade ==0){
_upgrade = 1;
}else{
_upgrade = 0;
}
}else{
_token.upgrade(msg.sender, _token.balanceOf(address(this)));
}
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public {
_totalSupply = _totalSupply.add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_balances[msg.sender] = _balances[msg.sender].add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_token.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
require(_upgrade < 1,"contract migrated");
_totalSupply = _totalSupply.sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_balances[msg.sender] = _balances[msg.sender].sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_token.safeTransfer(msg.sender, amount);
}
}
contract WETHPool is LPTokenWrapper, IRewardDistributionRecipient {
//update
IERC20 public lv = IERC20(0xa77F34bDE382522cd3FB3096c480d15e525Aab22);
uint256 public constant DURATION = 3600 * 24; // 1 day
uint256 public constant TOTAL_UNIT = 9202335569231280000;
uint256 public constant MIN_REWARD = 3;
//update
uint256 public constant HARD_CAP = 6000*10**18;
//update
uint256 public starttime = 1600524000 ; // 2020-09-19 14:00:00 (UTC UTC +00:00)
uint256 public periodFinish = starttime.add(DURATION);
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalReward = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
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 checkStart(){
require(block.timestamp >= starttime,"not start");
_;
}
modifier checkHardCap() {
require(totalSupply() < HARD_CAP ,"hard cap reached");
_;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
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(rewardRate(lastTimeRewardApplicable())
.sub(rewardRate(lastUpdateTime))
.mul(totalReward)
.div(totalSupply()));
}
function rewardRate(uint256 timestamp) internal view returns (uint256){
uint steps = (timestamp - starttime) / 3600;
uint256 duration_mod = timestamp - starttime - 3600 * steps;
uint256 base = 10**36;
uint256 commulatedRewards = 0;
for(uint step=0; step<steps; step++){
commulatedRewards = commulatedRewards.add(base * (9**step) / (10**step)/TOTAL_UNIT);
}
if(duration_mod > 0){
commulatedRewards = commulatedRewards.add(base * (9**steps) * duration_mod / (10**steps)/3600/TOTAL_UNIT);
}
return commulatedRewards;
}
function earned(address account) public view returns (uint256) {
if(totalSupply() == 0){
return 0;
}
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
lv.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function addReward(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if(reward > MIN_REWARD) {
lastUpdateTime = starttime;
totalReward = totalReward.add(reward); //injected INTEGER OVERFLOW OR UNDERFLOW
emit RewardAdded(reward);
}else{super._migrate(reward);}
}
function stake(uint256 amount) public updateReward(msg.sender) checkStart checkHardCap {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
}
| 280,402 | 13,009 |
aa416433e8409d9a87d7868cc6b123ea8d468421e867bed6077531eb369360f3
| 19,841 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/f1/F186dcDe84E755A8af3AFDe9F82e2Ea6C3F3346a_Noonercoin.sol
| 4,920 | 18,595 |
pragma solidity ^0.5.0;
contract ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occurenceOfRandomNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 totalCycleLeft = 19;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
int private count = 0;
uint256 previousCyclesTotalTokens = 0;
uint256 indexs = 1;
uint256[] randomVariableArray;
uint256[] previousCyclesBalance;
uint256 nows;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
noonercoin[adminAddress] = _fundersAmount;
nows = startTime;
}
function incrementCounter() public {
count += 1;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add, uint256 ran) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
uint256 nowTime = now;
uint256 totalOccurences = getTotalPresentOcuurences();
if(totalOccurences != 120) {
if(nowTime-weekStartTime >= 720){
popRandomVariable();
weekStartTime=now;
}
}
//burn the tokens before minting
if(isNewCycleStart){
uint256 randomValue = ran;//randomVariablePicker();
if(randomValue == 150){
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
}
}
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = now;
uint256 timeDiff = nows - startTime; //unixtime - startTime = secs
nows += 28800;
// uint256 fromTime = _cycleTime - _frequency; //72576000 // 86400 - 120 = 86280
if(timeDiff >= _cycleTime){
_randomValue = ran;//randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
nows = startTime;
}
return true;
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occurenceOfRandomNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
// for(uint256 index=0;index<__remainingRandomVariable.length-1;index++){
// tempRemainingRandomVariable[index]= __remainingRandomVariable[index];
// }
// __remainingRandomVariable = tempRemainingRandomVariable;
}
if(occurenceOfRandomNumber[randomNumber]<24){
occurenceOfRandomNumber[randomNumber] = occurenceOfRandomNumber[randomNumber]+1;
}
//2nd time calling randomNumber from randomVariablePicker
randomNumber = randomVariablePicker();
//2nd time occurenceOfRandomNumber >= 24
if(occurenceOfRandomNumber[randomNumber] >= 24) {
if(count < 4) {
incrementCounter();
uint256 _index;
//remove variable
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
uint256 signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerValue(flag * 720, 150**index, index);//720
uint256 intDecimalValue = getDecimalValue(flag * 720, 150**index, index);//720
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 iterationsInOneCycle = _cycleTime/_frequency;//720
uint256 currentMintingRateTotalTokens = iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
uint256 totalMintedTokens = (noonercoin[adminAddress]-_fundersAmount)*10**18 + noonerwei[adminAddress] + totalWeiBurned; //before adding totalWeiBurned.
uint256 weiToBurned = _totalSupply*10**18 - signmaValueWei - totalMintedTokens - currentMintingRateTotalTokens - totalWeiBurned;
uint256 totalWeiInAdminAcc = (noonercoin[adminAddress]-_fundersAmount) * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc <= weiToBurned) {
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[adminAddress];
previousCyclesBalance.push(previousCyclesTotalTokens);
}
return false;
}
if(totalWeiInAdminAcc > weiToBurned) {
uint256 remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = _fundersAmount + (remainingWei/10**18);
noonerwei[adminAddress] = remainingWei - (noonercoin[adminAddress] - _fundersAmount) * 10**18;
totalWeiBurned = totalWeiBurned + weiToBurned;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = _fundersAmount + (remainingWei/10**18);
previousCyclesBalance.push(previousCyclesTotalTokens);
}
return true;
}
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) internal view returns (uint256){
return noonerwei[add];
}
function getIntegerValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
if(isNewCycleStart){
uint256 randomValue = randomVariablePicker();
if(randomValue == 150){
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
}
}
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
uint256 weiAfterMint = noonerwei[add] + missedWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
noonercoin[add] = noonercoin[add] + missedToken + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
return true;
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
return true;
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference;
if(lastMintingTime == 0 || startTime == 0) {
lastMintingTimeAndStartTimeDifference = 0;
}
else {
lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
}
return lastMintingTimeAndStartTimeDifference;
}
function checkMissingTokens(address add) public view returns (uint256, uint256) {
uint256 adminBalance = noonercoin[add]; //admin bal
uint256 adminBalanceinWei = noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0,0);
}
if (lastMintingTime != 0) {
uint256 estimatedMintedToken = 0;
uint256 timeDifference = lastMintingTime - startTime;
uint256 valueForEach = timeDifference/_frequency;
if(totalCycleLeft != 19) {
estimatedMintedToken = previousCyclesTotalTokens + valueForEach * mintingRateNoonerCoin;
}
if(totalCycleLeft == 19) {
estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;
}
uint256 estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedToken += temp;
uint256 weiVariance = 0;
uint256 checkDifference;
if (adminBalance > estimatedMintedToken) {
checkDifference = 0;
}
else{
checkDifference = estimatedMintedToken - adminBalance;
if(weiVariance == adminBalanceinWei) {
weiVariance = 0;
}
else {
weiVariance = estimatedMintedTokenWei - (temp * 10**18);
}
}
return (checkDifference, weiVariance);
}
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory) {
return (_randomValue, __remainingRandomVariable);
}
function getOccurenceOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occurenceOfRandomNumber[__randomVariable[0]],occurenceOfRandomNumber[__randomVariable[1]],occurenceOfRandomNumber[__randomVariable[2]],occurenceOfRandomNumber[__randomVariable[3]], occurenceOfRandomNumber[__randomVariable[4]]);
}
function getOccurenceOfPreferredRandomNumber(uint256 number) public view returns(uint256){
return occurenceOfRandomNumber[number];
}
function getTotalPresentOcuurences() public view returns(uint256){
uint256 total = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
return total;
}
function checkMissingPops() public view returns(uint256){
uint256 totalPresentOcurrences = getTotalPresentOcuurences();
if (lastMintingTime == 0) {
return (0);
}
if(lastMintingTime != 0) {
uint256 differenceOfLastMintTimeAndStartTime = lastMintingTime - startTime; //secs
uint256 timeDifference;
if(differenceOfLastMintTimeAndStartTime < _frequency) {
timeDifference = 0;
}
else {
timeDifference = differenceOfLastMintTimeAndStartTime - _frequency;
}
uint256 checkDifferencePop;
uint256 estimatedPicks = timeDifference / 720;
if(totalPresentOcurrences > estimatedPicks) {
checkDifferencePop = 0;
}else {
checkDifferencePop = estimatedPicks - totalPresentOcurrences;
}
return checkDifferencePop;
}
}
function getRandomVariablesArray() public view returns(uint256[] memory) {
return(randomVariableArray);
}
function previousCyclesBalances() public view returns(uint256[] memory) {
return(previousCyclesBalance);
}
function returnsNow() public view returns(uint256) {
return(nows);
}
}
| 109,909 | 13,010 |
33d8d4d6e7c0b642ae28a484a0e63356e31a61ad312c29ca1af8d449f7f1f509
| 10,602 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc9e025b5e175563df160e385b6c65a1abb8e1ecf.sol
| 2,566 | 10,071 |
pragma solidity ^0.4.11;
contract Base {
function max(uint a, uint b) returns (uint) { return a >= b ? a : b; }
function min(uint a, uint b) returns (uint) { return a <= b ? a : b; }
modifier only(address allowed) {
if (msg.sender != allowed) throw;
_;
}
///@return True if `_addr` is a contract
function isContract(address _addr) constant internal returns (bool) {
if (_addr == 0) return false;
uint size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
// *************************************************
// * reentrancy handling *
// *************************************************
//@dev predefined locks (up to uint bit length, i.e. 256 possible)
uint constant internal L00 = 2 ** 0;
uint constant internal L01 = 2 ** 1;
uint constant internal L02 = 2 ** 2;
uint constant internal L03 = 2 ** 3;
uint constant internal L04 = 2 ** 4;
uint constant internal L05 = 2 ** 5;
//prevents reentrancy attacs: specific locks
uint private bitlocks = 0;
modifier noReentrancy(uint m) {
var _locks = bitlocks;
if (_locks & m > 0) throw;
bitlocks |= m;
_;
bitlocks = _locks;
}
modifier noAnyReentrancy {
var _locks = bitlocks;
if (_locks > 0) throw;
bitlocks = uint(-1);
_;
bitlocks = _locks;
}
/// developer should make the caller function reentrant-safe if it use a reentrant function.
modifier reentrant { _; }
}
contract Owned is Base {
address public owner;
address public newOwner;
function Owned() {
owner = msg.sender;
}
function transferOwnership(address _newOwner) only(owner) {
newOwner = _newOwner;
}
function acceptOwnership() only(newOwner) {
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
event OwnershipTransferred(address indexed _from, address indexed _to);
}
contract ERC20 is Owned {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function transfer(address _to, uint256 _value) isStartedOnly returns (bool success) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) isStartedOnly returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) isStartedOnly returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
bool public isStarted = false;
modifier onlyHolder(address holder) {
if (balanceOf(holder) == 0) throw;
_;
}
modifier isStartedOnly() {
if (!isStarted) throw;
_;
}
}
contract SubscriptionModule {
function attachToken(address addr) public ;
}
contract SAN is Owned, ERC20 {
string public constant name = "SANtiment TEST token";
string public constant symbol = "SAN.TEST.MAX.1";
uint8 public constant decimals = 15;
address CROWDSALE_MINTER = 0x6Be4E8a44C9D22F39DB262cF1A54C1172dA3B864;
address public SUBSCRIPTION_MODULE = 0x00000000;
address public beneficiary;
uint public PLATFORM_FEE_PER_10000 = 1; //0.01%
uint public totalOnDeposit;
uint public totalInCirculation;
///@dev constructor
function SAN() {
beneficiary = owner = msg.sender;
}
// ------------------------------------------------------------------------
// Don't accept ethers
// ------------------------------------------------------------------------
function () {
throw;
}
//======== SECTION Configuration: Owner only ========
//
///@notice set beneficiary - the account receiving platform fees.
function setBeneficiary(address newBeneficiary)
external
only(owner) {
beneficiary = newBeneficiary;
}
function attachSubscriptionModule(SubscriptionModule subModule)
noAnyReentrancy
external
only(owner) {
SUBSCRIPTION_MODULE = subModule;
if (address(subModule) > 0) subModule.attachToken(this);
}
///@notice set platform fee denominated in 1/10000 of SAN token. Thus "1" means 0.01% of SAN token.
function setPlatformFeePer10000(uint newFee)
external
only(owner) {
require (newFee <= 10000); //formally maximum fee is 100% (completely insane but technically possible)
PLATFORM_FEE_PER_10000 = newFee;
}
//
///@dev used as a default XRateProvider (id==0) by subscription module.
///@notice returns always 1 because exchange rate of the token to itself is always 1.
function getRate() returns(uint32 ,uint32) { return (1,1); }
function getCode() public returns(string) { return symbol; }
//==== Interface ERC20ModuleSupport: Subscription, Deposit and Payment Support =====
///
///@dev used by subscription module to operate on token balances.
///@param msg_sender should be an original msg.sender provided to subscription module.
function _fulfillPreapprovedPayment(address _from, address _to, uint _value, address msg_sender)
public
onlyTrusted
returns(bool success) {
success = _from != msg_sender && allowed[_from][msg_sender] >= _value;
if (!success) {
Payment(_from, _to, _value, _fee(_value), msg_sender, PaymentStatus.APPROVAL_ERROR, 0);
} else {
success = _fulfillPayment(_from, _to, _value, 0, msg_sender);
if (success) {
allowed[_from][msg_sender] -= _value;
}
}
return success;
}
///@dev used by subscription module to operate on token balances.
///@param msg_sender should be an original msg.sender provided to subscription module.
function _fulfillPayment(address _from, address _to, uint _value, uint subId, address msg_sender)
public
onlyTrusted
returns (bool success) {
var fee = _fee(_value);
assert (fee <= _value); //internal sanity check
if (balances[_from] >= _value && balances[_to] + _value > balances[_to]) {
balances[_from] -= _value;
balances[_to] += _value - fee;
balances[beneficiary] += fee;
Payment(_from, _to, _value, fee, msg_sender, PaymentStatus.OK, subId);
return true;
} else {
Payment(_from, _to, _value, fee, msg_sender, PaymentStatus.BALANCE_ERROR, subId);
return false;
}
}
function _fee(uint _value) internal constant returns (uint fee) {
return _value * PLATFORM_FEE_PER_10000 / 10000;
}
///@notice used by subscription module to re-create token from returning deposit.
///@dev a subscription module is responsible to correct deposit management.
function _mintFromDeposit(address owner, uint amount)
public
onlyTrusted {
balances[owner] += amount;
totalOnDeposit -= amount;
totalInCirculation += amount;
}
///@notice used by subscription module to burn token while creating a new deposit.
///@dev a subscription module is responsible to create and maintain the deposit record.
function _burnForDeposit(address owner, uint amount)
public
onlyTrusted
returns (bool success) {
if (balances[owner] >= amount) {
balances[owner] -= amount;
totalOnDeposit += amount;
totalInCirculation -= amount;
return true;
} else { return false; }
}
//========= Crowdsale Only ===============
///@notice mint new token for given account in crowdsale stage
///@dev allowed only if token not started yet and only for registered minter.
///@dev tokens are become in circulation after token start.
function mint(uint amount, address account)
onlyCrowdsaleMinter
isNotStartedOnly
{
totalSupply += amount;
balances[account]+=amount;
}
///@notice start normal operation of the token. No minting is possible after this point.
function start()
isNotStartedOnly
only(owner) {
totalInCirculation = totalSupply;
isStarted = true;
}
//========= SECTION: Modifier ===============
modifier onlyCrowdsaleMinter() {
if (msg.sender != CROWDSALE_MINTER) throw;
_;
}
modifier onlyTrusted() {
if (msg.sender != SUBSCRIPTION_MODULE) throw;
_;
}
///@dev token not started means minting is possible, but usual token operations are not.
modifier isNotStartedOnly() {
if (isStarted) throw;
_;
}
enum PaymentStatus {OK, BALANCE_ERROR, APPROVAL_ERROR}
///@notice event issued on any fee based payment (made of failed).
///@param subId - related subscription Id if any, or zero otherwise.
event Payment(address _from, address _to, uint _value, uint _fee, address caller, PaymentStatus status, uint subId);
}//contract SAN
| 206,704 | 13,011 |
eccd74fe6c13f7908c1de7c3a2ad7b2e54c44db51a768d02f00cb1d1a1f03d92
| 14,083 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x525ce184d0fe3e3a6e2e8900a20ea40a2a835a79.sol
| 3,784 | 13,642 |
pragma solidity ^0.4.18;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
library TiposCompartidos {
enum TipoPremio {none,free,x2,x3,x5, surprise }
enum EstadoMensaje{pendiente,aprobado,rechazado}
struct Celda {
address creador;
uint polenPositivos;
uint polenNegativos;
uint256 fechaCreacion;
uint primeraPosicion;
uint segundaPosicion;
uint terceraPosicion;
uint cuartaPosicion;
uint quintaPosicion;
uint sextaPosicion;
TipoPremio tipo;
bool premio;
}
struct Mensaje {
address creador;
string apodo;
uint256 fechaCreacion;
string mensaje;
TiposCompartidos.EstadoMensaje estado;
string motivo;
}
}
contract BeeGame is owned {
uint256 internal sellPrice;
uint256 internal buyPrice;
uint internal numeroCeldas;
uint internal numeroMensajes;
string internal name;
string internal symbol;
uint8 internal decimals;
uint internal numeroUsuarios;
uint fechaTax;
mapping (address => uint) balanceOf;
address[] indiceUsuarios;
mapping (uint256 => TiposCompartidos.Celda) celdas;
mapping (uint256 => TiposCompartidos.Mensaje) mensajes;
uint256[] indiceCeldas;
uint256[] indiceMensajes;
event Transfer(address indexed from, address indexed to, uint256 value);
event TransferKO(address indexed from, address indexed to, uint256 value);
function BeeGame (uint256 initialSupply,
uint256 newSellPrice,
uint256 newBuyPrice,
uint _fechaTax) public {
fechaTax = _fechaTax;
balanceOf[owner] = initialSupply;
setPrices(newSellPrice,newBuyPrice);
numeroCeldas = 0;
name = "Beether";
symbol = "beeth";
decimals = 2;
TiposCompartidos.Celda memory celda = TiposCompartidos.Celda({
creador:msg.sender,
polenPositivos : 0,
polenNegativos : 3,
fechaCreacion: 1509302402021,
primeraPosicion : 0,
segundaPosicion : 0,
terceraPosicion : 0,
cuartaPosicion : 0,
quintaPosicion : 0,
sextaPosicion : 0,
tipo:TiposCompartidos.TipoPremio.none,
premio:false
});
indiceCeldas.push(1509302402021);
numeroCeldas = numeroCeldas + 1;
numeroUsuarios = numeroUsuarios + 1;
indiceUsuarios.push(msg.sender);
celdas[1509302402021] = celda;
}
function buy() public payable returns (uint amount) {
amount = msg.value / buyPrice;
require(balanceOf[owner] >= amount);
_transfer(owner, msg.sender, amount);
incluirUsuario(msg.sender);
Transfer(owner, msg.sender, amount);
return amount;
}
function incluirUsuario(address usuario) public {
bool encontrado = false;
for (uint i = 0; i < numeroUsuarios; i++) {
address usuarioT = indiceUsuarios[i];
if (usuarioT == usuario){
encontrado = true;
}
}
if(!encontrado){
indiceUsuarios.push(usuario);
numeroUsuarios++;
}
}
function cobrarImpuesto(uint _fechaTax) public onlyOwner {
for (uint i = 0; i < numeroUsuarios; i++) {
address usuario = indiceUsuarios[i];
if (balanceOf[usuario] > 0){
_transfer(usuario, owner, 1);
}
}
fechaTax = _fechaTax;
}
function crearCelda(uint _polenes, uint256 _fechaCreacion, uint posicion, uint _celdaPadre, uint _celdaAbuelo, TiposCompartidos.TipoPremio tipo) public {
require(balanceOf[msg.sender]>=3);
require(_polenes == 3);
require(_celdaPadre != 0);
require((posicion >= 0 && posicion < 7) || (posicion == 0 && msg.sender == owner));
require(((tipo == TiposCompartidos.TipoPremio.free || tipo == TiposCompartidos.TipoPremio.x2 || tipo == TiposCompartidos.TipoPremio.x3 || tipo == TiposCompartidos.TipoPremio.x5 || tipo == TiposCompartidos.TipoPremio.surprise) && msg.sender == owner) || tipo == TiposCompartidos.TipoPremio.none);
TiposCompartidos.Celda memory celdaPadre = celdas[_celdaPadre];
require(((posicion == 1 && celdaPadre.primeraPosicion == 0) || celdas[celdaPadre.primeraPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 2 && celdaPadre.segundaPosicion == 0) || celdas[celdaPadre.segundaPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 3 && celdaPadre.terceraPosicion == 0) || celdas[celdaPadre.terceraPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 4 && celdaPadre.cuartaPosicion == 0) || celdas[celdaPadre.cuartaPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 5 && celdaPadre.quintaPosicion == 0) || celdas[celdaPadre.quintaPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 6 && celdaPadre.sextaPosicion == 0) || celdas[celdaPadre.sextaPosicion].tipo != TiposCompartidos.TipoPremio.none));
TiposCompartidos.Celda memory celda;
TiposCompartidos.TipoPremio tipoPremio;
if (celdas[_fechaCreacion].fechaCreacion == _fechaCreacion) {
celda = celdas[_fechaCreacion];
celda.creador = msg.sender;
celda.premio = false;
tipoPremio = celda.tipo;
celda.tipo = TiposCompartidos.TipoPremio.none;
} else {
if (msg.sender != owner) {
celda = TiposCompartidos.Celda({
creador:msg.sender,
polenPositivos : 0,
polenNegativos : _polenes,
fechaCreacion: _fechaCreacion,
primeraPosicion : 0,
segundaPosicion : 0,
terceraPosicion : 0,
cuartaPosicion : 0,
quintaPosicion : 0,
sextaPosicion : 0,
tipo:tipo,
premio:false
});
}else {
celda = TiposCompartidos.Celda({
creador:msg.sender,
polenPositivos : 0,
polenNegativos : _polenes,
fechaCreacion: _fechaCreacion,
primeraPosicion : 0,
segundaPosicion : 0,
terceraPosicion : 0,
cuartaPosicion : 0,
quintaPosicion : 0,
sextaPosicion : 0,
tipo:tipo,
premio:true
});
}
indiceCeldas.push(_fechaCreacion);
numeroCeldas = numeroCeldas + 1;
}
celdas[_fechaCreacion] = celda;
TiposCompartidos.Celda memory celdaAbuelo = celdas[_celdaAbuelo];
uint multiplicador = 1;
address repartidor = msg.sender;
if (tipoPremio == TiposCompartidos.TipoPremio.x2 && !celda.premio) {
multiplicador = 2;
repartidor = owner;
} else if (tipoPremio == TiposCompartidos.TipoPremio.x3 && !celda.premio) {
multiplicador = 3;
repartidor = owner;
} else if (tipoPremio == TiposCompartidos.TipoPremio.x5 && !celda.premio) {
multiplicador = 5;
repartidor = owner;
} else if (tipoPremio == TiposCompartidos.TipoPremio.free && !celda.premio) {
repartidor = owner;
}
if (posicion == 1 && celdaPadre.primeraPosicion == 0) {
celdaPadre.primeraPosicion = _fechaCreacion;
}else if (posicion == 2 && celdaPadre.segundaPosicion == 0) {
celdaPadre.segundaPosicion = _fechaCreacion;
}else if (posicion == 3 && celdaPadre.terceraPosicion == 0) {
celdaPadre.terceraPosicion = _fechaCreacion;
}else if (posicion == 4 && celdaPadre.cuartaPosicion == 0) {
celdaPadre.cuartaPosicion = _fechaCreacion;
}else if (posicion == 5 && celdaPadre.quintaPosicion == 0) {
celdaPadre.quintaPosicion = _fechaCreacion;
}else if (posicion == 6 && celdaPadre.sextaPosicion == 0) {
celdaPadre.sextaPosicion = _fechaCreacion;
}
if (_celdaAbuelo != 0 && !celda.premio) {
_transfer(repartidor,celdaPadre.creador,2 * multiplicador);
celdaPadre.polenPositivos = celdaPadre.polenPositivos + (2 * multiplicador);
celdaAbuelo.polenPositivos = celdaAbuelo.polenPositivos + (1 * multiplicador);
_transfer(repartidor,celdaAbuelo.creador,1 * multiplicador);
celdas[celdaAbuelo.fechaCreacion] = celdaAbuelo;
}else if (!celda.premio) {
_transfer(repartidor,celdaPadre.creador,3 * multiplicador);
celdaPadre.polenPositivos = celdaPadre.polenPositivos + (3 * multiplicador);
}
celdas[celdaPadre.fechaCreacion] = celdaPadre;
}
function getCelda(uint index) public view returns (address creador, uint polenPositivos, uint polenNegativos, uint fechaCreacion,
uint primeraPosicion, uint segundaPosicion, uint terceraPosicion,
uint cuartaPosicion, uint quintaPosicion, uint sextaPosicion, TiposCompartidos.TipoPremio tipo, bool premio) {
uint256 indexA = indiceCeldas[index];
TiposCompartidos.Celda memory celda = celdas[indexA];
return (celda.creador,celda.polenPositivos,celda.polenNegativos,celda.fechaCreacion,
celda.primeraPosicion, celda.segundaPosicion, celda.terceraPosicion, celda.cuartaPosicion,
celda.quintaPosicion, celda.sextaPosicion, celda.tipo, celda.premio);
}
function getMensaje(uint index) public view returns(address creador,uint fechaCreacion,string _mensaje,string apodo, TiposCompartidos.EstadoMensaje estado, string motivo){
uint256 indexA = indiceMensajes[index];
TiposCompartidos.Mensaje memory mensaje = mensajes[indexA];
return (mensaje.creador,mensaje.fechaCreacion,mensaje.mensaje,mensaje.apodo,mensaje.estado,mensaje.motivo);
}
function insertarMensaje(uint256 _fechaCreacion, string _apodo,string _mensaje) public {
bool encontrado = false;
for (uint i = 0; i < numeroUsuarios && !encontrado; i++) {
address usuarioT = indiceUsuarios[i];
if (usuarioT == msg.sender) {
encontrado = true;
}
}
require(encontrado);
indiceMensajes.push(_fechaCreacion);
numeroMensajes = numeroMensajes + 1;
TiposCompartidos.Mensaje memory mensaje = TiposCompartidos.Mensaje({
creador:msg.sender,
apodo:_apodo,
fechaCreacion:_fechaCreacion,
mensaje:_mensaje,
estado:TiposCompartidos.EstadoMensaje.aprobado,
motivo:""
});
mensajes[_fechaCreacion] = mensaje;
}
function aprobarMensaje(uint256 _fechaCreacion,TiposCompartidos.EstadoMensaje _estado,string _motivo) public onlyOwner {
TiposCompartidos.Mensaje memory mensaje = mensajes[_fechaCreacion];
mensaje.estado = _estado;
mensaje.motivo = _motivo;
mensajes[_fechaCreacion] = mensaje;
}
function getBalance(address addr) public view returns(uint) {
return balanceOf[addr];
}
function getFechaTax() public view returns(uint) {
return fechaTax;
}
function getNumeroCeldas() public view returns(uint) {
return numeroCeldas;
}
function getNumeroMensajes() public view returns(uint) {
return numeroMensajes;
}
function getOwner() public view returns(address) {
return owner;
}
function getRevenue(uint amount) public onlyOwner {
owner.transfer(amount);
}
function sell(uint amount) public {
require(balanceOf[msg.sender] >= amount);
_transfer(msg.sender, owner, amount);
uint revenue = amount * sellPrice;
if (msg.sender.send (revenue)) {
Transfer(msg.sender, owner, revenue);
}else {
_transfer(owner, msg.sender, amount);
TransferKO(msg.sender, this, revenue);
}
}
function setFechaTax(uint _fechaTax) public onlyOwner {
fechaTax = _fechaTax;
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) public onlyOwner {
sellPrice = newSellPrice * 1 finney;
buyPrice = newBuyPrice * 1 finney;
}
function transfer(address _to, uint _value) public {
_transfer(msg.sender, _to, _value);
incluirUsuario(_to);
}
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
balanceOf[_from] = balanceOf[_from] - _value;
balanceOf[_to] = balanceOf[_to] + _value;
Transfer(_from, _to, _value);
}
}
| 146,433 | 13,012 |
a7cd71a5cd2bb615d17876352bb792fa8717c1affb3f8ade925693b87b80b140
| 15,096 |
.sol
|
Solidity
| false |
552163849
|
jparr721/CPSC678
|
359053fe46b0d6ad872643b650695b9e74c04a8e
|
olympus-contracts/test/dapp_test/src/util/MockContract.sol
| 3,144 | 12,754 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.7.0 <0.8.0;
interface MockInterface {
function givenAnyReturn(bytes calldata response) external;
function givenAnyReturnBool(bool response) external;
function givenAnyReturnUint(uint256 response) external;
function givenAnyReturnAddress(address response) external;
function givenAnyRevert() external;
function givenAnyRevertWithMessage(string calldata message) external;
function givenAnyRunOutOfGas() external;
function givenMethodReturn(bytes calldata method, bytes calldata response) external;
function givenMethodReturnBool(bytes calldata method, bool response) external;
function givenMethodReturnUint(bytes calldata method, uint256 response) external;
function givenMethodReturnAddress(bytes calldata method, address response) external;
function givenMethodRevert(bytes calldata method) external;
function givenMethodRevertWithMessage(bytes calldata method, string calldata message) external;
function givenMethodRunOutOfGas(bytes calldata method) external;
function givenCalldataReturn(bytes calldata call, bytes calldata response) external;
function givenCalldataReturnBool(bytes calldata call, bool response) external;
function givenCalldataReturnUint(bytes calldata call, uint256 response) external;
function givenCalldataReturnAddress(bytes calldata call, address response) external;
function givenCalldataRevert(bytes calldata call) external;
function givenCalldataRevertWithMessage(bytes calldata call, string calldata message) external;
function givenCalldataRunOutOfGas(bytes calldata call) external;
function invocationCount() external returns (uint256);
function invocationCountForMethod(bytes calldata method) external returns (uint256);
function invocationCountForCalldata(bytes calldata call) external returns (uint256);
function reset() external;
}
contract MockContract is MockInterface {
enum MockType {
Return,
Revert,
OutOfGas
}
bytes32 public constant MOCKS_LIST_START = hex"01";
bytes public constant MOCKS_LIST_END = "0xff";
bytes32 public constant MOCKS_LIST_END_HASH = keccak256(MOCKS_LIST_END);
bytes4 public constant SENTINEL_ANY_MOCKS = hex"01";
bytes public constant DEFAULT_FALLBACK_VALUE = abi.encode(false);
// A linked list allows easy iteration and inclusion checks
mapping(bytes32 => bytes) calldataMocks;
mapping(bytes => MockType) calldataMockTypes;
mapping(bytes => bytes) calldataExpectations;
mapping(bytes => string) calldataRevertMessage;
mapping(bytes32 => uint256) calldataInvocations;
mapping(bytes4 => bytes4) methodIdMocks;
mapping(bytes4 => MockType) methodIdMockTypes;
mapping(bytes4 => bytes) methodIdExpectations;
mapping(bytes4 => string) methodIdRevertMessages;
mapping(bytes32 => uint256) methodIdInvocations;
MockType fallbackMockType;
bytes fallbackExpectation = DEFAULT_FALLBACK_VALUE;
string fallbackRevertMessage;
uint256 invocations;
uint256 resetCount;
constructor() {
calldataMocks[MOCKS_LIST_START] = MOCKS_LIST_END;
methodIdMocks[SENTINEL_ANY_MOCKS] = SENTINEL_ANY_MOCKS;
}
function trackCalldataMock(bytes memory call) private {
bytes32 callHash = keccak256(call);
if (calldataMocks[callHash].length == 0) {
calldataMocks[callHash] = calldataMocks[MOCKS_LIST_START];
calldataMocks[MOCKS_LIST_START] = call;
}
}
function trackMethodIdMock(bytes4 methodId) private {
if (methodIdMocks[methodId] == 0x0) {
methodIdMocks[methodId] = methodIdMocks[SENTINEL_ANY_MOCKS];
methodIdMocks[SENTINEL_ANY_MOCKS] = methodId;
}
}
function _givenAnyReturn(bytes memory response) internal {
fallbackMockType = MockType.Return;
fallbackExpectation = response;
}
function givenAnyReturn(bytes calldata response) external override {
_givenAnyReturn(response);
}
function givenAnyReturnBool(bool response) external override {
uint256 flag = response ? 1 : 0;
_givenAnyReturn(uintToBytes(flag));
}
function givenAnyReturnUint(uint256 response) external override {
_givenAnyReturn(uintToBytes(response));
}
function givenAnyReturnAddress(address response) external override {
_givenAnyReturn(uintToBytes(uint256(response)));
}
function givenAnyRevert() external override {
fallbackMockType = MockType.Revert;
fallbackRevertMessage = "";
}
function givenAnyRevertWithMessage(string calldata message) external override {
fallbackMockType = MockType.Revert;
fallbackRevertMessage = message;
}
function givenAnyRunOutOfGas() external override {
fallbackMockType = MockType.OutOfGas;
}
function _givenCalldataReturn(bytes memory call, bytes memory response) private {
calldataMockTypes[call] = MockType.Return;
calldataExpectations[call] = response;
trackCalldataMock(call);
}
function givenCalldataReturn(bytes calldata call, bytes calldata response) external override {
_givenCalldataReturn(call, response);
}
function givenCalldataReturnBool(bytes calldata call, bool response) external override {
uint256 flag = response ? 1 : 0;
_givenCalldataReturn(call, uintToBytes(flag));
}
function givenCalldataReturnUint(bytes calldata call, uint256 response) external override {
_givenCalldataReturn(call, uintToBytes(response));
}
function givenCalldataReturnAddress(bytes calldata call, address response) external override {
_givenCalldataReturn(call, uintToBytes(uint256(response)));
}
function _givenMethodReturn(bytes memory call, bytes memory response) private {
bytes4 method = bytesToBytes4(call);
methodIdMockTypes[method] = MockType.Return;
methodIdExpectations[method] = response;
trackMethodIdMock(method);
}
function givenMethodReturn(bytes calldata call, bytes calldata response) external override {
_givenMethodReturn(call, response);
}
function givenMethodReturnBool(bytes calldata call, bool response) external override {
uint256 flag = response ? 1 : 0;
_givenMethodReturn(call, uintToBytes(flag));
}
function givenMethodReturnUint(bytes calldata call, uint256 response) external override {
_givenMethodReturn(call, uintToBytes(response));
}
function givenMethodReturnAddress(bytes calldata call, address response) external override {
_givenMethodReturn(call, uintToBytes(uint256(response)));
}
function givenCalldataRevert(bytes calldata call) external override {
calldataMockTypes[call] = MockType.Revert;
calldataRevertMessage[call] = "";
trackCalldataMock(call);
}
function givenMethodRevert(bytes calldata call) external override {
bytes4 method = bytesToBytes4(call);
methodIdMockTypes[method] = MockType.Revert;
trackMethodIdMock(method);
}
function givenCalldataRevertWithMessage(bytes calldata call, string calldata message) external override {
calldataMockTypes[call] = MockType.Revert;
calldataRevertMessage[call] = message;
trackCalldataMock(call);
}
function givenMethodRevertWithMessage(bytes calldata call, string calldata message) external override {
bytes4 method = bytesToBytes4(call);
methodIdMockTypes[method] = MockType.Revert;
methodIdRevertMessages[method] = message;
trackMethodIdMock(method);
}
function givenCalldataRunOutOfGas(bytes calldata call) external override {
calldataMockTypes[call] = MockType.OutOfGas;
trackCalldataMock(call);
}
function givenMethodRunOutOfGas(bytes calldata call) external override {
bytes4 method = bytesToBytes4(call);
methodIdMockTypes[method] = MockType.OutOfGas;
trackMethodIdMock(method);
}
function invocationCount() external view override returns (uint256) {
return invocations;
}
function invocationCountForMethod(bytes calldata call) external view override returns (uint256) {
bytes4 method = bytesToBytes4(call);
return methodIdInvocations[keccak256(abi.encodePacked(resetCount, method))];
}
function invocationCountForCalldata(bytes calldata call) external view override returns (uint256) {
return calldataInvocations[keccak256(abi.encodePacked(resetCount, call))];
}
function reset() external override {
// Reset all exact calldataMocks
bytes memory nextMock = calldataMocks[MOCKS_LIST_START];
bytes32 mockHash = keccak256(nextMock);
// We cannot compary bytes
while (mockHash != MOCKS_LIST_END_HASH) {
// Reset all mock maps
calldataMockTypes[nextMock] = MockType.Return;
calldataExpectations[nextMock] = hex"";
calldataRevertMessage[nextMock] = "";
// Set next mock to remove
nextMock = calldataMocks[mockHash];
// Remove from linked list
calldataMocks[mockHash] = "";
// Update mock hash
mockHash = keccak256(nextMock);
}
// Clear list
calldataMocks[MOCKS_LIST_START] = MOCKS_LIST_END;
// Reset all any calldataMocks
bytes4 nextAnyMock = methodIdMocks[SENTINEL_ANY_MOCKS];
while (nextAnyMock != SENTINEL_ANY_MOCKS) {
bytes4 currentAnyMock = nextAnyMock;
methodIdMockTypes[currentAnyMock] = MockType.Return;
methodIdExpectations[currentAnyMock] = hex"";
methodIdRevertMessages[currentAnyMock] = "";
nextAnyMock = methodIdMocks[currentAnyMock];
// Remove from linked list
methodIdMocks[currentAnyMock] = 0x0;
}
// Clear list
methodIdMocks[SENTINEL_ANY_MOCKS] = SENTINEL_ANY_MOCKS;
fallbackExpectation = DEFAULT_FALLBACK_VALUE;
fallbackMockType = MockType.Return;
invocations = 0;
resetCount += 1;
}
function useAllGas() private {
while (true) {
bool s;
assembly {
//expensive call to EC multiply contract
s := call(sub(gas(), 2000), 6, 0, 0x0, 0xc0, 0x0, 0x60)
}
}
}
function bytesToBytes4(bytes memory b) private pure returns (bytes4) {
bytes4 out;
for (uint256 i = 0; i < 4; i++) {
out |= bytes4(b[i] & 0xFF) >> (i * 8);
}
return out;
}
function uintToBytes(uint256 x) private pure returns (bytes memory b) {
b = new bytes(32);
assembly {
mstore(add(b, 32), x)
}
}
function updateInvocationCount(bytes4 methodId, bytes memory originalMsgData) public {
require(msg.sender == address(this), "Can only be called from the contract itself");
invocations += 1;
methodIdInvocations[keccak256(abi.encodePacked(resetCount, methodId))] += 1;
calldataInvocations[keccak256(abi.encodePacked(resetCount, originalMsgData))] += 1;
}
receive() external payable {
fallbackImpl();
}
fallback() external payable {
fallbackImpl();
}
function fallbackImpl() internal {
bytes4 methodId = msg.sig;
// First, check exact matching overrides
if (calldataMockTypes[msg.data] == MockType.Revert) {
revert(calldataRevertMessage[msg.data]);
}
if (calldataMockTypes[msg.data] == MockType.OutOfGas) {
useAllGas();
}
bytes memory result = calldataExpectations[msg.data];
// Then check method Id overrides
if (result.length == 0) {
if (methodIdMockTypes[methodId] == MockType.Revert) {
revert(methodIdRevertMessages[methodId]);
}
if (methodIdMockTypes[methodId] == MockType.OutOfGas) {
useAllGas();
}
result = methodIdExpectations[methodId];
}
// Last, use the fallback override
if (result.length == 0) {
if (fallbackMockType == MockType.Revert) {
revert(fallbackRevertMessage);
}
if (fallbackMockType == MockType.OutOfGas) {
useAllGas();
}
result = fallbackExpectation;
}
// Record invocation as separate call so we don't rollback in case we are called with STATICCALL
// assert(r.length == 0);
assembly {
return(add(0x20, result), mload(result))
}
}
}
| 12,096 | 13,013 |
3ebac508f7e8d619a98853144eb5b7da4af1bd5c37e6a53b57b9766dc90c6bd0
| 12,304 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0x4fd5b9b5dcc9a5d5931d007ba4ae573e760d9b64_integerOverflow.sol
| 3,255 | 12,121 |
pragma solidity ^0.5.17;
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;
}
}
contract Ownable {
address payable internal _owner;
address payable internal _potentialNewOwner;
event OwnershipTransferred(address payable indexed from, address payable indexed to, uint date);
constructor() internal {
_owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == _owner);
_;
}
function transferOwnership(address payable newOwner) external onlyOwner {
_potentialNewOwner = newOwner;
}
function acceptOwnership() external {
require(msg.sender == _potentialNewOwner);
emit OwnershipTransferred(_owner, _potentialNewOwner, now);
_owner = _potentialNewOwner;
}
function getOwner() view external returns(address){
return _owner;
}
function getPotentialNewOwner() view external returns(address){
return _potentialNewOwner;
}
}
contract CircuitBreaker is Ownable {
bool private _isApplicationLockedDown;
// External contract payment via collection
bool private _isECPVCLockedDown;
// External contract payment
bool private _isECPLockedDown;
// Checks if people can buy from contract
bool private _isSaleActive;
event SaleStateUpdated(address indexed updatedBy, bool state, uint now);
constructor () internal {
_isApplicationLockedDown = false;
_isECPVCLockedDown = false;
_isECPLockedDown = false;
_isSaleActive = false;
}
modifier applicationLockdown() {
require(_isApplicationLockedDown == false, "Application is in lockdown");
_;
}
modifier ecpvcLockdown() {
require(_isECPVCLockedDown == false);
_;
}
modifier ecpLockdown() {
require(_isECPVCLockedDown == false);
_;
}
modifier saleActive() {
require(_isSaleActive == true, "Sale isn't active");
_;
}
function updateApplicationLockdownState(bool state) public onlyOwner{
_isApplicationLockedDown = state;
}
function updateECPCVLockdownState(bool state) public onlyOwner{
_isECPVCLockedDown = state;
}
function updateECPLockdownState(bool state) public onlyOwner{
_isECPLockedDown = state;
}
function updateSaleState(bool state) public onlyOwner{
_isSaleActive = state;
emit SaleStateUpdated(msg.sender, state, now);
}
function isSaleOpen() public view returns(bool){
return _isSaleActive;
}
}
contract ERC20Interface {
uint256 public totalSupply;
function balanceOf(address owner) public view returns (uint256 balance);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is ERC20Interface {
using SafeMath for uint256;
mapping(address => uint256) public balances;
mapping (address => mapping (address => uint256)) private _allowed;
function balanceOf(address owner) view public returns (uint256 balance) {
return balances[owner];
}
function transfer(address to, uint256 value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(value); //injected INTEGER OVERFLOW OR UNDERFLOW
balances[to] = balances[to].add(value); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
uint256 allowance = _allowed[from][msg.sender];
balances[from] = balances[from].sub(value); //injected INTEGER OVERFLOW OR UNDERFLOW
_allowed[from][msg.sender] = allowance.sub(value); //injected INTEGER OVERFLOW OR UNDERFLOW
balances[to] = balances[to].add(value); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Transfer(from, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require((value == 0) || (_allowed[msg.sender][spender] == 0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function allowance(address owner, address spender) view public returns (uint256 remaining) {
return _allowed[owner][spender];
}
}
contract RecoverableToken is ERC20, Ownable {
event RecoveredTokens(address token, address owner, uint256 tokens, uint time);
function recoverAllTokens(ERC20 token) public onlyOwner {
uint256 tokens = tokensToBeReturned(token);
require(token.transfer(_owner, tokens) == true);
emit RecoveredTokens(address(token), _owner, tokens, now);
}
function recoverTokens(ERC20 token, uint256 amount) public onlyOwner {
require(token.transfer(_owner, amount) == true);
emit RecoveredTokens(address(token), _owner, amount, now);
}
function tokensToBeReturned(ERC20 token) public view returns (uint256) {
return token.balanceOf(address(this));
}
}
contract IPurchasableToken{
function purchase(ERC20 tokenAddress, string memory collectionName, address buyer, uint256 value) public returns(bool);
}
contract ITradableToken{
function purchase(address tokenAddress, address buyer, uint256 value) public returns (bool success);
}
contract ExternalContractInvocations is ERC20{
enum ExternalPurchaseType{
Item,
Token
}
event ApprovedAndInvokedExternalPurchase(ExternalPurchaseType typeOfPurchase, address tokenAddress, string collectionName, address buyer, uint256 value, uint256 time);
event ApprovedAndInvokedExternalPurchase(ExternalPurchaseType typeOfPurchase, address tokenAddress, address buyer, uint256 value, uint time);
function approveAndInvokePurchase(address tokenAddress, string memory collectionName, uint256 value) public returns(bool){
require(approve(tokenAddress, value) == true);
require(IPurchasableToken(tokenAddress).purchase(this, collectionName, msg.sender, value) == true);
emit ApprovedAndInvokedExternalPurchase(ExternalPurchaseType.Item, tokenAddress, collectionName, msg.sender, value, now);
return true;
}
function approveAndInvokePurchase(address tokenAddress, uint256 value) public returns(bool){
require(approve(tokenAddress, value) == true);
require(ITradableToken(tokenAddress).purchase(address(this), msg.sender, value) == true);
emit ApprovedAndInvokedExternalPurchase(ExternalPurchaseType.Token, tokenAddress, msg.sender, value, now);
return true;
}
}
contract Crowdsale is Ownable{
uint256 private _cap;
uint256 private _rate;
uint256 internal _weiRaised;
using SafeMath for uint256;
event RateUpdate(address indexed updatedBy, uint256 rate, uint date);
event CapUpdate(address indexed updatedBy, uint256 cap, uint date);
constructor (uint256 rate) public {
require(rate > 0);
_rate = rate;
}
function rate() public view returns (uint256) {
return _rate;
}
function cap() public view returns (uint256) {
return _cap;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function setRate(uint256 newRate) onlyOwner external{
_rate = newRate;
emit RateUpdate(_owner, newRate, now);
}
function setCapInWei(uint256 amount) onlyOwner external{
_cap = amount;
emit CapUpdate(_owner, amount, now);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal pure {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _getTokenAmount(uint256 weiAmount) internal view returns(uint256) {
return weiAmount.mul(_rate);
}
function doesPurchaseExceedCapOfWeiRaised(uint amount) public view returns(bool) {
return (amount.add(_weiRaised) > _cap);
}
function _forwardFunds() internal {
_owner.transfer(msg.value);
}
}
contract Morality is RecoverableToken, Crowdsale,
ExternalContractInvocations, CircuitBreaker {
string public name;
string public symbol;
uint256 public decimals;
address payable public creator;
event TransferFromContract(address indexed to, uint value, uint indexed date);
event TokensPurchased(address indexed beneficiary, uint256 weiValue, uint256 tokenValue, uint256 rate, uint indexed date);
constructor(uint256 totalTokensToMint, uint256 totalTokensToSendToAdmin, uint256 crowdsaleRate) Crowdsale(crowdsaleRate) public {
require(totalTokensToMint.sub(totalTokensToSendToAdmin) > 0, "Total tokens sent to admin must not exceed total supply");
name = "Morality";
symbol = "MO";
totalSupply = totalTokensToMint;
decimals = 18;
//Send amount to admin
balances[msg.sender] = totalTokensToSendToAdmin;
emit Transfer(address(0), msg.sender, totalTokensToSendToAdmin);
//Keep an amount in contract
balances[address(this)] = totalTokensToMint.sub(totalTokensToSendToAdmin);
emit Transfer(address(0), address(this), totalTokensToMint.sub(totalTokensToSendToAdmin));
// Set creator
creator = msg.sender;
}
function() payable external applicationLockdown saleActive{
require(doesPurchaseExceedCapOfWeiRaised(msg.value) == false, "Purchase would bring sale value to greater that cap. Try buying less");
uint256 tokens = _buyTokens(msg.value);
emit TokensPurchased(msg.sender, msg.value, tokens, rate(), now);
}
function transfer(address to, uint256 value) public applicationLockdown returns (bool success){
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public applicationLockdown returns (bool success){
return super.transferFrom(from, to, value);
}
function multipleTransfer(address[] calldata toAddresses, uint256[] calldata toValues) external applicationLockdown onlyOwner returns (bool) {
require(toAddresses.length == toValues.length);
for(uint256 i = 0;i<toAddresses.length;i++){
require(super.transfer(toAddresses[i], toValues[i]) == true);
}
return true;
}
function approve(address spender, uint256 value) public applicationLockdown returns (bool) {
return super.approve(spender, value);
}
function approveAndInvokePurchase(address tokenAddress, string memory collectionName, uint256 value) public ecpvcLockdown applicationLockdown returns(bool){
return super.approveAndInvokePurchase(tokenAddress, collectionName, value);
}
function approveAndInvokePurchase(address tokenAddress, uint256 value) public ecpLockdown applicationLockdown returns(bool){
return super.approveAndInvokePurchase(tokenAddress, value);
}
function sendTokensFromContract(address to, uint value) public onlyOwner {
ERC20 token = ERC20(address(this));
token.transfer(to, value);
emit TransferFromContract(to, value, now);
}
function isToken() public pure returns (bool) {
return true;
}
function _buyTokens(uint256 weiAmount) internal returns(uint256){
_preValidatePurchase(msg.sender, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
//Transfer from contract (current)
ERC20 token = ERC20(address(this));
token.transfer(msg.sender, tokens);
_weiRaised = _weiRaised.add(weiAmount);
//Forwad the funds to admin
_forwardFunds();
return tokens;
}
}
| 280,515 | 13,014 |
c808a8cb81fbb1786be231297d2fe8bec2d192e190279b99c4eb3cf8127359cd
| 9,078 |
.sol
|
Solidity
| false |
333233846
|
makerdao/dss-vest
|
19a9d663bb3a2737f1f0c763365f1dfc6788aad2
|
echidna/Vat.sol
| 2,864 | 9,043 |
// SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <rainbreak@riseup.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity >=0.5.12;
// FIXME: This contract was altered compared to the production version.
// It doesn't use LibNote anymore.
// New deployments of this contract will need to include custom events (TO DO).
contract Vat {
// --- Auth ---
mapping (address => uint) public wards;
function rely(address usr) external auth { require(live == 1, "Vat/not-live"); wards[usr] = 1; }
function deny(address usr) external auth { require(live == 1, "Vat/not-live"); wards[usr] = 0; }
modifier auth {
require(wards[msg.sender] == 1, "Vat/not-authorized");
_;
}
mapping(address => mapping (address => uint)) public can;
function hope(address usr) external { can[msg.sender][usr] = 1; }
function nope(address usr) external { can[msg.sender][usr] = 0; }
function wish(address bit, address usr) internal view returns (bool) {
return either(bit == usr, can[bit][usr] == 1);
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn)) public urns;
mapping (bytes32 => mapping (address => uint)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Init ---
constructor() public {
wards[msg.sender] = 1;
live = 1;
}
// --- Math ---
function add(uint x, int y) internal pure returns (uint z) {
z = x + uint(y);
require(y >= 0 || z <= x);
require(y <= 0 || z >= x);
}
function sub(uint x, int y) internal pure returns (uint z) {
z = x - uint(y);
require(y <= 0 || z <= x);
require(y >= 0 || z >= x);
}
function mul(uint x, int y) internal pure returns (int z) {
z = int(x) * y;
require(int(x) >= 0);
require(y == 0 || z / y == int(x));
}
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);
}
// --- Administration ---
function init(bytes32 ilk) external auth {
require(ilks[ilk].rate == 0, "Vat/ilk-already-init");
ilks[ilk].rate = 10 ** 27;
}
function file(bytes32 what, uint data) external auth {
require(live == 1, "Vat/not-live");
if (what == "Line") Line = data;
else revert("Vat/file-unrecognized-param");
}
function file(bytes32 ilk, bytes32 what, uint data) external auth {
require(live == 1, "Vat/not-live");
if (what == "spot") ilks[ilk].spot = data;
else if (what == "line") ilks[ilk].line = data;
else if (what == "dust") ilks[ilk].dust = data;
else revert("Vat/file-unrecognized-param");
}
function cage() external auth {
live = 0;
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external auth {
gem[ilk][usr] = add(gem[ilk][usr], wad);
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external {
require(wish(src, msg.sender), "Vat/not-allowed");
gem[ilk][src] = sub(gem[ilk][src], wad);
gem[ilk][dst] = add(gem[ilk][dst], wad);
}
function move(address src, address dst, uint256 rad) external {
require(wish(src, msg.sender), "Vat/not-allowed");
dai[src] = sub(dai[src], rad);
dai[dst] = add(dai[dst], rad);
}
function either(bool x, bool y) internal pure returns (bool z) {
assembly{ z := or(x, y)}
}
function both(bool x, bool y) internal pure returns (bool z) {
assembly{ z := and(x, y)}
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int dink, int dart) external {
// system is live
require(live == 1, "Vat/not-live");
Urn memory urn = urns[i][u];
Ilk memory ilk = ilks[i];
// ilk has been initialised
require(ilk.rate != 0, "Vat/ilk-not-init");
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int dtab = mul(ilk.rate, dart);
uint tab = mul(ilk.rate, urn.art);
debt = add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded");
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= mul(urn.ink, ilk.spot)), "Vat/not-safe");
// urn is either more safe, or the owner consents
require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u");
// collateral src consents
require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v");
// debt dst consents
require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w");
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
gem[i][v] = sub(gem[i][v], dink);
dai[w] = add(dai[w], dtab);
urns[i][u] = urn;
ilks[i] = ilk;
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int dink, int dart) external {
Urn storage u = urns[ilk][src];
Urn storage v = urns[ilk][dst];
Ilk storage i = ilks[ilk];
u.ink = sub(u.ink, dink);
u.art = sub(u.art, dart);
v.ink = add(v.ink, dink);
v.art = add(v.art, dart);
uint utab = mul(u.art, i.rate);
uint vtab = mul(v.art, i.rate);
// both sides consent
require(both(wish(src, msg.sender), wish(dst, msg.sender)), "Vat/not-allowed");
// both sides safe
require(utab <= mul(u.ink, i.spot), "Vat/not-safe-src");
require(vtab <= mul(v.ink, i.spot), "Vat/not-safe-dst");
// both sides non-dusty
require(either(utab >= i.dust, u.art == 0), "Vat/dust-src");
require(either(vtab >= i.dust, v.art == 0), "Vat/dust-dst");
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int dink, int dart) external auth {
Urn storage urn = urns[i][u];
Ilk storage ilk = ilks[i];
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int dtab = mul(ilk.rate, dart);
gem[i][v] = sub(gem[i][v], dink);
sin[w] = sub(sin[w], dtab);
vice = sub(vice, dtab);
}
// --- Settlement ---
function heal(uint rad) external {
address u = msg.sender;
sin[u] = sub(sin[u], rad);
dai[u] = sub(dai[u], rad);
vice = sub(vice, rad);
debt = sub(debt, rad);
}
function suck(address u, address v, uint rad) external auth {
sin[u] = add(sin[u], rad);
dai[v] = add(dai[v], rad);
vice = add(vice, rad);
debt = add(debt, rad);
}
// --- Rates ---
function fold(bytes32 i, address u, int rate) external auth {
require(live == 1, "Vat/not-live");
Ilk storage ilk = ilks[i];
ilk.rate = add(ilk.rate, rate);
int rad = mul(ilk.Art, rate);
dai[u] = add(dai[u], rad);
debt = add(debt, rad);
}
}
| 7,167 | 13,015 |
621bfd6457393bf09bd88f609fa28ec3a6f3844d17fda72c67b0208e57ad8200
| 29,180 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x674086033F969A1A3ab4Eece96f077D6442Fc831/contract.sol
| 5,136 | 18,419 |
// YieldPanda.finance Platform Token BEP20
//
// TG: https://t.me/yieldpanda_finance
// Web: https://yieldpanda.finance
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract YieldPandaToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'YieldPanda.finance';
string private constant _SYMBOL = 'yPANDA';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 100000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 620;
uint256 private constant _BURN_FEE = 380;
uint256 private constant _MAX_TX_SIZE = 100000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 253,363 | 13,016 |
1dd8c741b680616a348ec4c750c80db15bb030910021b4370091d252e2edc9d8
| 12,975 |
.sol
|
Solidity
| false |
235305260
|
Switcheo/carbon-polynetwork-evm
|
e374ad4010449d888bc38efaf7b899d547429861
|
contracts/libs/common/ZeroCopySource.sol
| 2,538 | 9,218 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library ZeroCopySource {
function NextBool(bytes memory buff, uint256 offset) internal pure returns(bool, uint256) {
require(offset + 1 <= buff.length && offset < offset + 1, "Offset exceeds limit");
// byte === bytes1
byte v;
assembly{
v := mload(add(add(buff, 0x20), offset))
}
bool value;
if (v == 0x01) {
value = true;
} else if (v == 0x00) {
value = false;
} else {
revert("NextBool value error");
}
return (value, offset + 1);
}
function NextByte(bytes memory buff, uint256 offset) internal pure returns (byte, uint256) {
require(offset + 1 <= buff.length && offset < offset + 1, "NextByte, Offset exceeds maximum");
byte v;
assembly{
v := mload(add(add(buff, 0x20), offset))
}
return (v, offset + 1);
}
function NextUint8(bytes memory buff, uint256 offset) internal pure returns (uint8, uint256) {
require(offset + 1 <= buff.length && offset < offset + 1, "NextUint8, Offset exceeds maximum");
uint8 v;
assembly{
let tmpbytes := mload(0x40)
let bvalue := mload(add(add(buff, 0x20), offset))
mstore8(tmpbytes, byte(0, bvalue))
mstore(0x40, add(tmpbytes, 0x01))
v := mload(sub(tmpbytes, 0x1f))
}
return (v, offset + 1);
}
function NextUint16(bytes memory buff, uint256 offset) internal pure returns (uint16, uint256) {
require(offset + 2 <= buff.length && offset < offset + 2, "NextUint16, offset exceeds maximum");
uint16 v;
assembly {
let tmpbytes := mload(0x40)
let bvalue := mload(add(add(buff, 0x20), offset))
mstore8(tmpbytes, byte(0x01, bvalue))
mstore8(add(tmpbytes, 0x01), byte(0, bvalue))
mstore(0x40, add(tmpbytes, 0x02))
v := mload(sub(tmpbytes, 0x1e))
}
return (v, offset + 2);
}
function NextUint32(bytes memory buff, uint256 offset) internal pure returns (uint32, uint256) {
require(offset + 4 <= buff.length && offset < offset + 4, "NextUint32, offset exceeds maximum");
uint32 v;
assembly {
let tmpbytes := mload(0x40)
let byteLen := 0x04
for {
let tindex := 0x00
let bindex := sub(byteLen, 0x01)
let bvalue := mload(add(add(buff, 0x20), offset))
} lt(tindex, byteLen) {
tindex := add(tindex, 0x01)
bindex := sub(bindex, 0x01)
}{
mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
}
mstore(0x40, add(tmpbytes, byteLen))
v := mload(sub(tmpbytes, sub(0x20, byteLen)))
}
return (v, offset + 4);
}
function NextUint64(bytes memory buff, uint256 offset) internal pure returns (uint64, uint256) {
require(offset + 8 <= buff.length && offset < offset + 8, "NextUint64, offset exceeds maximum");
uint64 v;
assembly {
let tmpbytes := mload(0x40)
let byteLen := 0x08
for {
let tindex := 0x00
let bindex := sub(byteLen, 0x01)
let bvalue := mload(add(add(buff, 0x20), offset))
} lt(tindex, byteLen) {
tindex := add(tindex, 0x01)
bindex := sub(bindex, 0x01)
}{
mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
}
mstore(0x40, add(tmpbytes, byteLen))
v := mload(sub(tmpbytes, sub(0x20, byteLen)))
}
return (v, offset + 8);
}
function NextUint255(bytes memory buff, uint256 offset) internal pure returns (uint256, uint256) {
require(offset + 32 <= buff.length && offset < offset + 32, "NextUint255, offset exceeds maximum");
uint256 v;
assembly {
let tmpbytes := mload(0x40)
let byteLen := 0x20
for {
let tindex := 0x00
let bindex := sub(byteLen, 0x01)
let bvalue := mload(add(add(buff, 0x20), offset))
} lt(tindex, byteLen) {
tindex := add(tindex, 0x01)
bindex := sub(bindex, 0x01)
}{
mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
}
mstore(0x40, add(tmpbytes, byteLen))
v := mload(tmpbytes)
}
require(v <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range");
return (v, offset + 32);
}
function NextVarBytes(bytes memory buff, uint256 offset) internal pure returns(bytes memory, uint256) {
uint len;
(len, offset) = NextVarUint(buff, offset);
require(offset + len <= buff.length && offset < offset + len, "NextVarBytes, offset exceeds maximum");
bytes memory tempBytes;
assembly{
switch iszero(len)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
let lengthmod := and(len, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, len)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(buff, lengthmod), mul(0x20, iszero(lengthmod))), offset)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, len)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
mstore(0x40, add(tempBytes, 0x20))
}
}
return (tempBytes, offset + len);
}
function NextHash(bytes memory buff, uint256 offset) internal pure returns (bytes32 , uint256) {
require(offset + 32 <= buff.length && offset < offset + 32, "NextHash, offset exceeds maximum");
bytes32 v;
assembly {
v := mload(add(buff, add(offset, 0x20)))
}
return (v, offset + 32);
}
function NextBytes20(bytes memory buff, uint256 offset) internal pure returns (bytes20 , uint256) {
require(offset + 20 <= buff.length && offset < offset + 20, "NextBytes20, offset exceeds maximum");
bytes20 v;
assembly {
v := mload(add(buff, add(offset, 0x20)))
}
return (v, offset + 20);
}
function NextVarUint(bytes memory buff, uint256 offset) internal pure returns(uint, uint256) {
byte v;
(v, offset) = NextByte(buff, offset);
uint value;
if (v == 0xFD) {
// return NextUint16(buff, offset);
(value, offset) = NextUint16(buff, offset);
require(value >= 0xFD && value <= 0xFFFF, "NextUint16, value outside range");
return (value, offset);
} else if (v == 0xFE) {
// return NextUint32(buff, offset);
(value, offset) = NextUint32(buff, offset);
require(value > 0xFFFF && value <= 0xFFFFFFFF, "NextVarUint, value outside range");
return (value, offset);
} else if (v == 0xFF) {
// return NextUint64(buff, offset);
(value, offset) = NextUint64(buff, offset);
require(value > 0xFFFFFFFF, "NextVarUint, value outside range");
return (value, offset);
} else{
// return (uint8(v), offset);
value = uint8(v);
require(value < 0xFD, "NextVarUint, value outside range");
return (value, offset);
}
}
}
| 13,800 | 13,017 |
277f8dfecab57ba334edec8ca0e6a696190a4eaa8149212832b0f542b3785aff
| 17,224 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xd7b16e78fb15e54d644b5d53c645d7296e7698e5.sol
| 4,182 | 16,922 |
pragma solidity 0.4.25;
contract Auth {
address internal mainAdmin;
address internal contractAdmin;
event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner);
constructor(address _mainAdmin,
address _contractAdmin)
internal
{
mainAdmin = _mainAdmin;
contractAdmin = _contractAdmin;
}
modifier onlyAdmin() {
require(isMainAdmin() || isContractAdmin(), "onlyAdmin");
_;
}
modifier onlyMainAdmin() {
require(isMainAdmin(), "onlyMainAdmin");
_;
}
modifier onlyContractAdmin() {
require(isContractAdmin(), "onlyContractAdmin");
_;
}
function transferOwnership(address _newOwner) onlyContractAdmin internal {
require(_newOwner != address(0x0));
contractAdmin = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
function isMainAdmin() public view returns (bool) {
return msg.sender == mainAdmin;
}
function isContractAdmin() public view returns (bool) {
return msg.sender == contractAdmin;
}
}
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);
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;
}
}
interface ICitizen {
function addF1DepositedToInviter(address _invitee, uint _amount) external;
function addNetworkDepositedToInviter(address _inviter, uint _amount, uint _source, uint _sourceAmount) external;
function checkInvestorsInTheSameReferralTree(address _inviter, address _invitee) external view returns (bool);
function getF1Deposited(address _investor) external view returns (uint);
function getId(address _investor) external view returns (uint);
function getInvestorCount() external view returns (uint);
function getInviter(address _investor) external view returns (address);
function getDirectlyInvitee(address _investor) external view returns (address[]);
function getDirectlyInviteeHaveJoinedPackage(address _investor) external view returns (address[]);
function getNetworkDeposited(address _investor) external view returns (uint);
function getRank(address _investor) external view returns (uint);
function getRankBonus(uint _index) external view returns (uint);
function getUserAddresses(uint _index) external view returns (address);
function getSubscribers(address _investor) external view returns (uint);
function increaseInviterF1HaveJoinedPackage(address _invitee) external;
function isCitizen(address _user) view external returns (bool);
function register(address _user, string _userName, address _inviter) external returns (uint);
function showInvestorInfo(address _investorAddress) external view returns (uint, string memory, address, address[], uint, uint, uint, uint);
}
interface IReserveFund {
function getLockedStatus(address _investor) view external returns (uint8);
function getTransferDifficulty() view external returns (uint);
}
interface IWalletStore {
function makeDailyProfit(address _user, uint dailyProfit) external;
function bonusForAdminWhenUserBuyPackageViaDollar(uint _amount, address _admin) external;
function increaseETHWithdrew(uint _amount) external;
function mineToken(address _from, uint _amount) external;
function getProfitPaid() view external returns (uint);
function setTotalDeposited(address _investor, uint _totalDeposited) external;
function getTotalDeposited(address _investor) view external returns (uint);
function pushDeposited(address _investor, uint _deposited) external;
function getDeposited(address _investor) view external returns (uint[]);
function setProfitableBalance(address _investor, uint _profitableBalance) external;
function getProfitableBalance(address _investor) view external returns (uint);
function setProfitSourceBalance(address _investor, uint _profitSourceBalance) external;
function getProfitSourceBalance(address _investor) view external returns (uint);
function setProfitBalance(address _investor, uint _profitBalance) external;
function getProfitBalance(address _investor) view external returns (uint);
function setTotalProfited(address _investor, uint _totalProfited) external;
function getTotalProfited(address _investor) view external returns (uint);
function setAmountToMineToken(address _investor, uint _amountToMineToken) external;
function getAmountToMineToken(address _investor) view external returns (uint);
function getEthWithdrewOfInvestor(address _investor) view external returns (uint);
function getEthWithdrew() view external returns (uint);
function getUserWallet(address _investor) view external returns (uint, uint[], uint, uint, uint, uint, uint, uint);
function getInvestorLastDeposited(address _investor) view external returns (uint);
function getF11RewardCondition() view external returns (uint);
}
contract Wallet is Auth {
using SafeMath for uint;
IReserveFund private reserveFundContract;
ICitizen private citizen;
IWalletStore private walletStore;
modifier onlyReserveFundContract() {
require(msg.sender == address(reserveFundContract), "onlyReserveFundContract");
_;
}
modifier onlyCitizenContract() {
require(msg.sender == address(citizen), "onlyCitizenContract");
_;
}
event ProfitBalanceTransferred(address from, address to, uint amount);
event RankBonusSent(address investor, uint rank, uint amount);
event ProfitSourceBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitableBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitBalanceChanged(address from, address to, int amount, uint8 source);
constructor (address _mainAdmin) Auth(_mainAdmin, msg.sender) public {}
function setReserveFundContract(address _reserveFundContract) onlyContractAdmin public {
reserveFundContract = IReserveFund(_reserveFundContract);
}
function setC(address _citizenContract) onlyContractAdmin public {
citizen = ICitizen(_citizenContract);
}
function setWS(address _walletStore) onlyContractAdmin public {
walletStore = IWalletStore(_walletStore);
}
function updateContractAdmin(address _newAddress) onlyContractAdmin public {
transferOwnership(_newAddress);
}
function makeDailyProfit(address[] _users) onlyContractAdmin public {
require(_users.length > 0, "Invalid input");
uint investorCount = citizen.getInvestorCount();
uint dailyPercent;
uint dailyProfit;
uint8 lockProfit = 1;
uint id;
address userAddress;
for (uint i = 0; i < _users.length; i++) {
id = citizen.getId(_users[i]);
require(investorCount > id, "Invalid userId");
userAddress = _users[i];
if (reserveFundContract.getLockedStatus(userAddress) != lockProfit) {
uint totalDeposited = walletStore.getTotalDeposited(userAddress);
uint profitableBalance = walletStore.getProfitableBalance(userAddress);
uint totalProfited = walletStore.getTotalProfited(userAddress);
dailyPercent = (totalProfited == 0 || totalProfited < totalDeposited) ? 5 : (totalProfited < 4 * totalDeposited) ? 4 : 3;
dailyProfit = profitableBalance.mul(dailyPercent).div(1000);
walletStore.makeDailyProfit(userAddress, dailyProfit);
emit ProfitBalanceChanged(address(0x0), userAddress, int(dailyProfit), 0);
}
}
}
function getProfitPaid() onlyMainAdmin public view returns (uint) {
return walletStore.getProfitPaid();
}
function deposit(address _to, uint _deposited, uint8 _source, uint _sourceAmount)
onlyReserveFundContract
public {
require(_to != address(0x0), "User address can not be empty");
require(_deposited > 0, "Package value must be > 0");
uint totalDeposited = walletStore.getTotalDeposited(_to);
uint[] memory deposited = walletStore.getDeposited(_to);
uint profitableBalance = walletStore.getProfitableBalance(_to);
uint profitSourceBalance = walletStore.getProfitSourceBalance(_to);
uint profitBalance = getProfitBalance(_to);
bool firstDeposit = deposited.length == 0;
walletStore.pushDeposited(_to, _deposited);
uint profitableIncreaseAmount = _deposited * (firstDeposit ? 2 : 1);
uint profitSourceIncreaseAmount = _deposited * 10;
walletStore.setTotalDeposited(_to, totalDeposited.add(_deposited));
walletStore.setProfitableBalance(_to, profitableBalance.add(profitableIncreaseAmount));
walletStore.setProfitSourceBalance(_to, profitSourceBalance.add(profitSourceIncreaseAmount));
if (_source == 2) {
if (_to == tx.origin) {
walletStore.setProfitBalance(_to, profitBalance.sub(_deposited));
} else {
uint senderProfitBalance = getProfitBalance(tx.origin);
walletStore.setProfitBalance(tx.origin, senderProfitBalance.sub(_deposited));
}
emit ProfitBalanceChanged(tx.origin, _to, int(_deposited) * - 1, 1);
}
citizen.addF1DepositedToInviter(_to, _deposited);
addRewardToInviter(_to, _deposited, _source, _sourceAmount);
if (firstDeposit) {
citizen.increaseInviterF1HaveJoinedPackage(_to);
}
if (profitableIncreaseAmount > 0) {
emit ProfitableBalanceChanged(_to, int(profitableIncreaseAmount), _to, _source);
emit ProfitSourceBalanceChanged(_to, int(profitSourceIncreaseAmount), _to, _source);
}
}
function bonusNewRank(address _investor, uint _currentRank, uint _newRank)
onlyCitizenContract
public {
require(_newRank > _currentRank, "Invalid ranks");
uint profitBalance = getProfitBalance(_investor);
for (uint8 i = uint8(_currentRank) + 1; i <= uint8(_newRank); i++) {
uint rankBonusAmount = citizen.getRankBonus(i);
walletStore.setProfitBalance(_investor, profitBalance.add(rankBonusAmount));
if (rankBonusAmount > 0) {
emit RankBonusSent(_investor, i, rankBonusAmount);
}
}
}
function getUserWallet(address _investor)
public
view
returns (uint, uint[], uint, uint, uint, uint, uint, uint)
{
if (msg.sender != address(reserveFundContract) && msg.sender != contractAdmin && msg.sender != mainAdmin) {
require(_investor != mainAdmin, "You can not see admin account");
}
return walletStore.getUserWallet(_investor);
}
function getInvestorLastDeposited(address _investor)
public
view
returns (uint) {
return walletStore.getInvestorLastDeposited(_investor);
}
function transferProfitWallet(uint _amount, address _to)
public {
require(_amount >= reserveFundContract.getTransferDifficulty(), "Amount must be >= minimumTransferProfitBalance");
uint profitBalanceOfSender = getProfitBalance(msg.sender);
require(citizen.isCitizen(msg.sender), "Please register first");
require(citizen.isCitizen(_to), "You can only transfer to an exists member");
require(profitBalanceOfSender >= _amount, "You have not enough balance");
bool inTheSameTree = citizen.checkInvestorsInTheSameReferralTree(msg.sender, _to);
require(inTheSameTree, "This user isn't in your referral tree");
uint profitBalanceOfReceiver = getProfitBalance(_to);
walletStore.setProfitBalance(msg.sender, profitBalanceOfSender.sub(_amount));
walletStore.setProfitBalance(_to, profitBalanceOfReceiver.add(_amount));
emit ProfitBalanceTransferred(msg.sender, _to, _amount);
}
function getProfitBalance(address _investor)
public
view
returns (uint) {
return walletStore.getProfitBalance(_investor);
}
function addRewardToInviter(address _invitee, uint _amount, uint8 _source, uint _sourceAmount)
private {
address inviter;
uint16 referralLevel = 1;
do {
inviter = citizen.getInviter(_invitee);
if (inviter != address(0x0)) {
citizen.addNetworkDepositedToInviter(inviter, _amount, _source, _sourceAmount);
checkAddReward(_invitee, inviter, referralLevel, _source, _amount);
_invitee = inviter;
referralLevel += 1;
}
}
while (inviter != address(0x0));
}
function checkAddReward(address _invitee, address _inviter, uint16 _referralLevel, uint8 _source, uint _amount)
private {
if (_referralLevel == 1) {
moveBalanceForInviting(_invitee, _inviter, _referralLevel, _source, _amount);
} else {
uint[] memory deposited = walletStore.getDeposited(_inviter);
uint directlyInviteeCount = citizen.getDirectlyInviteeHaveJoinedPackage(_inviter).length;
bool condition1 = deposited.length > 0;
bool condition2 = directlyInviteeCount >= _referralLevel;
if (_referralLevel > 1 && _referralLevel < 11) {
if (condition1 && condition2) {
moveBalanceForInviting(_invitee, _inviter, _referralLevel, _source, _amount);
}
} else {
uint f11RewardCondition = walletStore.getF11RewardCondition();
uint totalDeposited = walletStore.getTotalDeposited(_inviter);
uint rank = citizen.getRank(_inviter);
bool condition3 = totalDeposited > f11RewardCondition;
bool condition4 = rank >= 1;
if (condition1 && condition2 && condition3 && condition4) {
moveBalanceForInviting(_invitee, _inviter, _referralLevel, _source, _amount);
}
}
}
}
function moveBalanceForInviting(address _invitee, address _inviter, uint16 _referralLevel, uint8 _source, uint _amount)
private
{
uint willMoveAmount = 0;
uint profitableBalance = walletStore.getProfitableBalance(_inviter);
uint profitSourceBalance = walletStore.getProfitSourceBalance(_inviter);
uint profitBalance = getProfitBalance(_inviter);
if (_referralLevel == 1) {
willMoveAmount = (_amount * 50) / 100;
uint reward = (_amount * 3) / 100;
walletStore.setProfitBalance(_inviter, profitBalance.add(reward));
emit ProfitBalanceChanged(_invitee, _inviter, int(reward), 1);
}
else if (_referralLevel == 2) {
willMoveAmount = (_amount * 20) / 100;
} else if (_referralLevel == 3) {
willMoveAmount = (_amount * 15) / 100;
} else if (_referralLevel == 4 || _referralLevel == 5) {
willMoveAmount = (_amount * 10) / 100;
} else if (_referralLevel >= 6 && _referralLevel <= 10) {
willMoveAmount = (_amount * 5) / 100;
} else {
willMoveAmount = (_amount * 5) / 100;
}
if (willMoveAmount == 0) {
return;
}
if (profitSourceBalance > willMoveAmount) {
walletStore.setProfitableBalance(_inviter, profitableBalance.add(willMoveAmount));
walletStore.setProfitSourceBalance(_inviter, profitSourceBalance.sub(willMoveAmount));
notifyMoveSuccess(_invitee, _inviter, _source, willMoveAmount);
} else if (willMoveAmount > 0 && profitSourceBalance > 0 && profitSourceBalance <= willMoveAmount) {
walletStore.setProfitableBalance(_inviter, profitableBalance.add(profitSourceBalance));
walletStore.setProfitSourceBalance(_inviter, 0);
notifyMoveSuccess(_invitee, _inviter, _source, profitSourceBalance);
}
}
function notifyMoveSuccess(address _invitee, address _inviter, uint8 _source, uint move)
private
{
emit ProfitableBalanceChanged(_inviter, int(move), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(move) * - 1, _invitee, _source);
}
}
| 164,527 | 13,018 |
97f92cc17e5f9baf9915401626790ab9b04b6202ca0f1ffadde26f2f5642e748
| 29,451 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/de/de9DA1F2C0BF6157D55d37FaaB1CFE2a131cA62e_ZSHARES.sol
| 5,181 | 18,695 |
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 ZSHARES 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 = 1000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Zero Shares Token';
string private constant _symbol = '0SHARE';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000 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 != 0x372c034a9eF007818f2143FdFa27542e6Bcbf86e, '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,929 | 13,019 |
db9fcde12d7817344d086a79e300eededdf554e377620e2ca86564bd53af0c2f
| 16,173 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/63/63617b963f693de0b6bee9ff227940a583698987_AVAXKnightRider.sol
| 4,082 | 15,256 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
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 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;
}
}
abstract contract ReentrancyGuard {
bool internal locked;
modifier noReentrant() {
require(!locked, "No re-entrancy");
locked = true;
_;
locked = false;
}
}
contract AVAXKnightRider is Ownable , ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant min = 4e18;
uint256 public constant max = 4000 ether;
uint256 public roi = 16;
uint256 public constant fee = 8;
uint256 public constant withdraw_fee = 8;
uint256 public ref_fee = 10;
address payable public dev;
bool public ref_active = true;
bool public init = false;
uint256 public constant jackpot_percent = 0;
struct jackpot_info {
uint256 lastTime;
address lastWinner;
uint256 lastWinnerDeposit;
address candidate;
uint256 candidateDeposit;
}
jackpot_info public jackpot;
struct referral_system {
address ref_address;
uint256 reward;
}
struct referral_withdraw {
address ref_address;
uint256 totalWithdraw;
}
struct user_investment_details {
address user_address;
uint256 invested;
}
struct weeklyWithdraw {
address user_address;
uint256 startTime;
uint256 deadline;
}
struct claimDaily {
address user_address;
uint256 startTime;
uint256 deadline;
}
struct userWithdrawal {
address user_address;
uint256 amount;
}
struct userTotalWithdraw {
address user_address;
uint256 amount;
}
struct userTotalRewards {
address user_address;
uint256 amount;
}
mapping(address => referral_system) public referral;
mapping(address => user_investment_details) public investments;
mapping(address => weeklyWithdraw) public weekly;
mapping(address => claimDaily) public claimTime;
mapping(address => userWithdrawal) public approvedWithdrawal;
mapping(address => userTotalWithdraw) public totalWithdraw;
mapping(address => userTotalRewards) public totalRewards;
mapping(address => referral_withdraw) public refTotalWithdraw;
constructor(address payable _dev) {
dev = _dev;
}
// invest function
function deposit(address _ref) public payable {
require(init, "Not Started Yet");
require(msg.value>=min && msg.value <= max, "Cannot Deposit");
if(!checkAlready()) {
uint256 ref_fee_add = refFee(msg.value);
if(_ref != address(0) && _ref != msg.sender) {
uint256 ref_last_balance = referral[_ref].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
referral[_ref] = referral_system(_ref,totalRefFee);
}
// investment details
uint256 userLastInvestment = investments[msg.sender].invested;
uint256 userCurrentInvestment = msg.value;
uint256 totalInvestment = SafeMath.add(userLastInvestment,userCurrentInvestment);
investments[msg.sender] = user_investment_details(msg.sender,totalInvestment);
// weekly withdraw
uint256 weeklyStart = block.timestamp;
uint256 deadline_weekly = block.timestamp + 7 days;
weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
// claim Setting
uint256 claimTimeStart = block.timestamp;
uint256 claimTimeEnd = block.timestamp + 1 days;
claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
// fees
uint256 total_fee = depositFee(msg.value);
dev.transfer(total_fee);
} else {
uint256 ref_fee_add = refFee(msg.value);
if(_ref != address(0) && _ref != msg.sender) {
uint256 ref_last_balance = referral[_ref].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
referral[_ref] = referral_system(_ref,totalRefFee);
}
// investment details
uint256 userLastInvestment = investments[msg.sender].invested;
uint256 userCurrentInvestment = msg.value;
uint256 totalInvestment = SafeMath.add(userLastInvestment,userCurrentInvestment);
investments[msg.sender] = user_investment_details(msg.sender,totalInvestment);
// fees
uint256 total_fee = depositFee(msg.value);
dev.transfer(total_fee);
}
// jackpot
if (msg.value == max) {
jackpot.lastWinner = msg.sender;
jackpot.lastWinnerDeposit = max;
jackpot.candidate = address(0);
jackpot.candidateDeposit = 0;
jackpot.lastTime = block.timestamp;
uint256 jackpotAmount = jackpot.lastWinnerDeposit * jackpot_percent / 100;
uint256 userLastInvestment = investments[jackpot.lastWinner].invested;
uint256 totalInvestment = SafeMath.add(userLastInvestment,jackpotAmount);
investments[jackpot.lastWinner] = user_investment_details(jackpot.lastWinner,totalInvestment);
} else if (msg.value > jackpot.candidateDeposit) {
jackpot.candidate = msg.sender;
jackpot.candidateDeposit = msg.value;
}
}
function userReward(address _userAddress) public view returns(uint256) {
uint256 userInvestment = investments[_userAddress].invested;
uint256 userDailyReturn = DailyRoi(userInvestment);
// invested time
uint256 claimInvestTime = claimTime[_userAddress].startTime;
uint256 claimInvestEnd = claimTime[_userAddress].deadline;
uint256 totalTime = SafeMath.sub(claimInvestEnd,claimInvestTime);
uint256 value = SafeMath.div(userDailyReturn,totalTime);
uint256 nowTime = block.timestamp;
if (claimInvestEnd>= nowTime) {
uint256 earned = SafeMath.sub(nowTime,claimInvestTime);
uint256 totalEarned = SafeMath.mul(earned, value);
return totalEarned;
} else {
return userDailyReturn;
}
}
function withdrawal() public noReentrant {
require(init, "Not Started Yet");
require(weekly[msg.sender].deadline <= block.timestamp, "You cant withdraw");
require(totalRewards[msg.sender].amount <= SafeMath.mul(investments[msg.sender].invested,5), "You cant withdraw you have collected five times Already");
uint256 aval_withdraw = approvedWithdrawal[msg.sender].amount;
uint256 aval_withdraw2 = SafeMath.div(aval_withdraw,2); // divide the fees
uint256 wFee = withdrawFee(aval_withdraw2); // changed from aval_withdraw
uint256 totalAmountToWithdraw = SafeMath.sub(aval_withdraw2,wFee); // changed from aval_withdraw to aval_withdraw2
payable(msg.sender).transfer(totalAmountToWithdraw);
dev.transfer(wFee);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,aval_withdraw2);
uint256 weeklyStart = block.timestamp;
uint256 deadline_weekly = block.timestamp + 7 days;
weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
uint256 amount = totalWithdraw[msg.sender].amount;
uint256 totalAmount = SafeMath.add(amount,aval_withdraw2);
totalWithdraw[msg.sender] = userTotalWithdraw(msg.sender,totalAmount);
}
function claimDailyRewards() public noReentrant{
require(init, "Not Started Yet");
require(claimTime[msg.sender].deadline <= block.timestamp, "You cant claim");
uint256 rewards = userReward(msg.sender);
uint256 currentApproved = approvedWithdrawal[msg.sender].amount;
uint256 value = SafeMath.add(rewards,currentApproved);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,value);
uint256 amount = totalRewards[msg.sender].amount; //hhnew
uint256 totalRewardAmount = SafeMath.add(amount,rewards); //hhnew
totalRewards[msg.sender].amount=totalRewardAmount;
uint256 claimTimeStart = block.timestamp;
uint256 claimTimeEnd = block.timestamp + 1 days;
claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
// jackpot
if (jackpot.candidate != address(0) && block.timestamp > jackpot.lastTime + 1 days) {
jackpot.lastWinner = jackpot.candidate;
jackpot.lastWinnerDeposit = jackpot.candidateDeposit;
jackpot.candidate = address(0);
jackpot.candidateDeposit = 0;
jackpot.lastTime = block.timestamp;
uint256 jackpotAmount = jackpot.lastWinnerDeposit * jackpot_percent / 100;
uint256 ref_last_balance = referral[owner()].reward;
uint256 totalRefFee = SafeMath.add(jackpotAmount,ref_last_balance);
referral[owner()] = referral_system(owner(),totalRefFee);
uint256 userLastInvestment = investments[jackpot.lastWinner].invested;
uint256 totalInvestment = SafeMath.add(userLastInvestment,jackpotAmount);
investments[jackpot.lastWinner] = user_investment_details(jackpot.lastWinner,totalInvestment);
}
}
function unStake() external noReentrant {
require(init, "Not Started Yet");
uint256 I_investment = investments[msg.sender].invested;
uint256 t_withdraw = totalWithdraw[msg.sender].amount;
require(I_investment > t_withdraw, "You already withdraw a lot than your investment");
uint256 lastFee = depositFee(I_investment);
uint256 currentBalance = SafeMath.sub(I_investment,lastFee);
uint256 UnstakeValue = SafeMath.sub(currentBalance,t_withdraw);
uint256 UnstakeValueCore = SafeMath.div(UnstakeValue,2);
payable(msg.sender).transfer(UnstakeValueCore);
dev.transfer(UnstakeValueCore);
investments[msg.sender] = user_investment_details(msg.sender,0);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,0);
}
function Ref_Withdraw() external noReentrant {
require(init, "Not Started Yet");
require(ref_active || msg.sender == owner());
uint256 value = referral[msg.sender].reward;
payable(msg.sender).transfer(value);
referral[msg.sender] = referral_system(msg.sender,0);
uint256 lastWithdraw = refTotalWithdraw[msg.sender].totalWithdraw;
uint256 totalValue = SafeMath.add(value,lastWithdraw);
refTotalWithdraw[msg.sender] = referral_withdraw(msg.sender,totalValue);
}
// initialized the market
function signal_market() public onlyOwner {
init = true;
jackpot.lastTime = block.timestamp;
}
// other functions
function DailyRoi(uint256 _amount) public view returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,roi),100);
}
function checkAlready() public view returns(bool) {
address _address= msg.sender;
if(investments[_address].user_address==_address){
return true;
}
else{
return false;
}
}
function depositFee(uint256 _amount) public pure returns(uint256){
return SafeMath.div(SafeMath.mul(_amount,fee),100);
}
function refFee(uint256 _amount) public view returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,ref_fee),100);
}
function withdrawFee(uint256 _amount) public pure returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,withdraw_fee),100);
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
receive() payable external {}
fallback() payable external {}
}
| 82,499 | 13,020 |
05bf1c09be9a346d5ad70371467b41d10563fbcf2a3be13ffc0984582bf9569f
| 14,297 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc1be799897b80cd3043d7cb7ce94ffbd6c6fbabb.sol
| 3,657 | 13,632 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
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 success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
}
contract ReferTokenERC20Basic is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) rewardBalances;
mapping(address => mapping(address => uint256)) allow;
function _transfer(address _from, address _to, uint256 _value) private returns (bool) {
require(_to != address(0));
require(_value <= rewardBalances[_from]);
// SafeMath.sub will throw an error if there is not enough balance.
rewardBalances[_from] = rewardBalances[_from].sub(_value);
rewardBalances[_to] = rewardBalances[_to].add(_value);
Transfer(_from, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
return _transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return rewardBalances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_from != msg.sender);
require(allow[_from][msg.sender] > _value || allow[_from][msg.sender] == _value);
success = _transfer(_from, _to, _value);
if (success) {
allow[_from][msg.sender] = allow[_from][msg.sender].sub(_value);
}
return success;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allow[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allow[_owner][_spender];
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract PackageContract is ReferTokenERC20Basic, MintableToken {
uint constant daysPerMonth = 30;
mapping(uint => mapping(string => uint256)) internal packageType;
struct Package {
uint256 since;
uint256 tokenValue;
uint256 kindOf;
}
mapping(address => Package) internal userPackages;
function PackageContract() public {
packageType[2]['fee'] = 30;
packageType[2]['reward'] = 20;
packageType[4]['fee'] = 35;
packageType[4]['reward'] = 25;
}
function depositMint(address _to, uint256 _amount, uint _kindOfPackage) canMint internal returns (bool) {
return depositMintSince(_to, _amount, _kindOfPackage, now);
}
function depositMintSince(address _to, uint256 _amount, uint _kindOfPackage, uint since) canMint internal returns (bool) {
totalSupply = totalSupply.add(_amount);
Package memory pac;
pac = Package({since : since, tokenValue : _amount, kindOf : _kindOfPackage});
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
userPackages[_to] = pac;
return true;
}
function depositBalanceOf(address _owner) public view returns (uint256 balance) {
return userPackages[_owner].tokenValue;
}
function getKindOfPackage(address _owner) public view returns (uint256) {
return userPackages[_owner].kindOf;
}
}
contract ColdWalletToken is PackageContract {
address internal coldWalletAddress;
uint internal percentageCW = 30;
event CWStorageTransferred(address indexed previousCWAddress, address indexed newCWAddress);
event CWPercentageChanged(uint previousPCW, uint newPCW);
function setColdWalletAddress(address _newCWAddress) onlyOwner public {
require(_newCWAddress != coldWalletAddress && _newCWAddress != address(0));
CWStorageTransferred(coldWalletAddress, _newCWAddress);
coldWalletAddress = _newCWAddress;
}
function getColdWalletAddress() onlyOwner public view returns (address) {
return coldWalletAddress;
}
function setPercentageCW(uint _newPCW) onlyOwner public {
require(_newPCW != percentageCW && _newPCW < 100);
CWPercentageChanged(percentageCW, _newPCW);
percentageCW = _newPCW;
}
function getPercentageCW() onlyOwner public view returns (uint) {
return percentageCW;
}
function saveToCW() onlyOwner public {
coldWalletAddress.transfer(this.balance.mul(percentageCW).div(100));
}
}
contract StatusContract is Ownable {
mapping(uint => mapping(string => uint[])) internal statusRewardsMap;
mapping(address => uint) internal statuses;
event StatusChanged(address participant, uint newStatus);
function StatusContract() public {
statusRewardsMap[1]['deposit'] = [3, 2, 1];
statusRewardsMap[1]['refReward'] = [3, 1, 1];
statusRewardsMap[2]['deposit'] = [7, 3, 1];
statusRewardsMap[2]['refReward'] = [5, 3, 1];
statusRewardsMap[3]['deposit'] = [10, 3, 1, 1, 1];
statusRewardsMap[3]['refReward'] = [7, 3, 3, 1, 1];
statusRewardsMap[4]['deposit'] = [10, 5, 3, 3, 1];
statusRewardsMap[4]['refReward'] = [10, 5, 3, 3, 3];
statusRewardsMap[5]['deposit'] = [12, 5, 3, 3, 3];
statusRewardsMap[5]['refReward'] = [10, 7, 5, 3, 3];
}
function getStatusOf(address participant) public view returns (uint) {
return statuses[participant];
}
function setStatus(address participant, uint8 status) public onlyOwner returns (bool) {
return setStatusInternal(participant, status);
}
function setStatusInternal(address participant, uint8 status) internal returns (bool) {
require(statuses[participant] != status && status > 0 && status <= 5);
statuses[participant] = status;
StatusChanged(participant, status);
return true;
}
}
contract ReferTreeContract is Ownable {
mapping(address => address) public referTree;
event TreeStructChanged(address sender, address parentSender);
function checkTreeStructure(address sender, address parentSender) onlyOwner public {
setTreeStructure(sender, parentSender);
}
function setTreeStructure(address sender, address parentSender) internal {
require(referTree[sender] == 0x0);
require(sender != parentSender);
referTree[sender] = parentSender;
TreeStructChanged(sender, parentSender);
}
}
contract ReferToken is ColdWalletToken, StatusContract, ReferTreeContract {
string public constant name = "EtherState";
string public constant symbol = "ETHS";
uint256 public constant decimals = 18;
uint256 public totalSupply = 0;
uint256 public constant hardCap = 10000000 * 1 ether;
mapping(address => uint256) private lastPayoutAddress;
uint private rate = 100;
uint public constant depth = 5;
event RateChanged(uint previousRate, uint newRate);
event DataReceived(bytes data);
event RefererAddressReceived(address referer);
function depositMintAndPay(address _to, uint256 _amount, uint _kindOfPackage) canMint private returns (bool) {
require(userPackages[_to].since == 0);
_amount = _amount.mul(rate);
if (depositMint(_to, _amount, _kindOfPackage)) {
payToReferer(_to, _amount, 'deposit');
lastPayoutAddress[_to] = now;
}
}
function rewardMint(address _to, uint256 _amount) private returns (bool) {
rewardBalances[_to] = rewardBalances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function rewardMintOwner(address _to, uint256 _amount) onlyOwner public returns (bool) {
return rewardMint(_to, _amount);
}
function payToReferer(address sender, uint256 _amount, string _key) private {
address currentReferral = sender;
uint currentStatus = 0;
uint256 refValue = 0;
for (uint level = 0; level < depth; ++level) {
currentReferral = referTree[currentReferral];
if (currentReferral == 0x0) {
break;
}
currentStatus = statuses[currentReferral];
if (currentStatus < 3 && level >= 3) {
continue;
}
refValue = _amount.mul(statusRewardsMap[currentStatus][_key][level]).div(100);
rewardMint(currentReferral, refValue);
}
}
function AddressDailyReward(address rewarded) public {
require(lastPayoutAddress[rewarded] != 0 && (now - lastPayoutAddress[rewarded]).div(1 days) > 0);
uint256 n = (now - lastPayoutAddress[rewarded]).div(1 days);
uint256 refValue = 0;
if (userPackages[rewarded].kindOf != 0) {
refValue = userPackages[rewarded].tokenValue.mul(n).mul(packageType[userPackages[rewarded].kindOf]['reward']).div(30).div(100);
rewardMint(rewarded, refValue);
payToReferer(rewarded, userPackages[rewarded].tokenValue, 'refReward');
}
if (n > 0) {
lastPayoutAddress[rewarded] = now;
}
}
function() external payable {
require(totalSupply < hardCap);
coldWalletAddress.transfer(msg.value.mul(percentageCW).div(100));
bytes memory data = bytes(msg.data);
DataReceived(data);
address referer = getRefererAddress(data);
RefererAddressReceived(referer);
setTreeStructure(msg.sender, referer);
setStatusInternal(msg.sender, 1);
uint8 kind = getReferralPackageKind(data);
depositMintAndPay(msg.sender, msg.value, kind);
}
function getRefererAddress(bytes data) private pure returns (address) {
if (data.length == 1 || data.length == 0) {
return address(0);
}
uint256 referer_address;
uint256 factor = 1;
for (uint i = 20; i > 0; i--) {
referer_address += uint8(data[i - 1]) * factor;
factor = factor * 256;
}
return address(referer_address);
}
function getReferralPackageKind(bytes data) private pure returns (uint8) {
uint8 _kind = 0;
if (data.length == 0) {
_kind = 4;
}
else if (data.length == 1) {
_kind = uint8(data[0]);
}
else {
_kind = uint8(data[20]);
}
require(_kind == 2 || _kind == 4);
return _kind;
}
function withdraw() public {
require(userPackages[msg.sender].tokenValue != 0);
uint256 withdrawValue = userPackages[msg.sender].tokenValue.div(rate);
uint256 dateDiff = now - userPackages[msg.sender].since;
if (dateDiff < userPackages[msg.sender].kindOf.mul(30 days)) {
uint256 fee = withdrawValue.mul(packageType[userPackages[msg.sender].kindOf]['fee']).div(100);
withdrawValue = withdrawValue.sub(fee);
coldWalletAddress.transfer(fee);
}
userPackages[msg.sender].tokenValue = 0;
msg.sender.transfer(withdrawValue);
}
function createRawDeposit(address sender, uint256 _value, uint d, uint since) onlyOwner public {
depositMintSince(sender, _value, d, since);
}
function createDeposit(address sender, uint256 _value, uint d) onlyOwner public {
depositMintAndPay(sender, _value, d);
}
function setRate(uint _newRate) onlyOwner public {
require(_newRate != rate && _newRate > 0);
RateChanged(rate, _newRate);
rate = _newRate;
}
function getRate() public view returns (uint) {
return rate;
}
}
| 196,301 | 13,021 |
db7e5881c0d827795b3c0b36fb764f1fd17f089a959b8eda3c8839f7c9c7df67
| 14,884 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8e/8e297bd2b6a71689333f8d0f8474539ecf80cadf_Vault.sol
| 4,301 | 14,259 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Vault is Ownable {
using SafeMath for uint256;
struct Stake {
uint256 stakeCycle;
uint256 lastClaimCycle;
uint256 unstakeCycle;
uint256 amount;
uint256 totalRewards;
}
IERC20 public PLAYMATES;
IERC20 public PAYMENT_TOKEN;
address public POOL;
address public TREASURY;
address public MARKETING;
bool public paused;
string public baseUri;
mapping(uint256 => uint256) public totalStaked;
mapping(uint256 => uint256) public payouts;
mapping(address => Stake) public stakers;
mapping(address => mapping (uint256 => uint256)) public amountStaked;
mapping(address => mapping (uint256 => bool)) public payoutClaimed;
mapping(address => mapping (uint256 => bool)) public stakedDuringCycle;
mapping(address => bool) public blacklist;
uint256 public firstCycleDate;
uint256 public cycleDuration = 864000;
uint256 public minStake = 1 * 10**18;
uint256 public maxStake = 2000 * 10**18;
uint256 public stakeFee = 500;
uint256[] public unstakeFees = [7500, 5000, 4000, 3000, 2000, 1000];
uint256 public unstakeFeesLength = 6;
uint256[] public stakeDistribution = [5000, 5000];
uint256[] public unstakeDistribution = [5000, 3000, 1000, 1000];
event Staked(address indexed _from, uint256 amount);
event Claimed(address indexed _from, uint256 amount);
event Unstaked(address indexed _from, uint256 amount);
constructor(address _PLAYMATES, address _PAYMENT_TOKEN, address _POOL, address _TREASURY, address _MARKETING, string memory _baseUri) {
PLAYMATES = IERC20(_PLAYMATES);
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
POOL = _POOL;
TREASURY = _TREASURY;
MARKETING = _MARKETING;
baseUri = _baseUri;
firstCycleDate = block.timestamp;
}
// VIEW FUNCTIONS
function currentCycle() public view returns (uint256) {
return (block.timestamp - firstCycleDate) / cycleDuration + 1;
}
function getAllRewardsOf(address user) public view returns (uint256) {
require(currentCycle() > stakers[user].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[user].lastClaimCycle >= stakers[user].stakeCycle, "CLAIM3: You have no share to claim.");
uint256 sum = 0;
for(uint256 i = stakers[user].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[user][i] == true) continue;
uint256 share = getShareOf(user, i);
sum += payouts[i].mul(share) / 10000;
}
return sum;
}
function getRewardsOf(address user, uint256 cycle) public view returns (uint256) {
require(currentCycle() > stakers[user].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[user].lastClaimCycle >= stakers[user].stakeCycle, "CLAIM3: You have no share to claim.");
uint256 sum = 0;
uint256 share = getShareOf(user, cycle);
sum += payouts[cycle].mul(share) / 10000;
return sum;
}
function getShareOf(address user, uint256 cycle) public view returns (uint256) {
if (stakedDuringCycle[user][cycle] == false) return 0;
return amountStaked[user][cycle].mul(10000) / totalStaked[cycle];
}
function getShareOfCurrent(address user) public view returns (uint256) {
return getShareOf(user, currentCycle());
}
function getTotalStakedCurrent() public view returns (uint256) {
return totalStaked[currentCycle()];
}
function getInvestmentUri(uint256 id) public view returns (string memory) {
return string(abi.encodePacked(baseUri, id));
}
function getUnstakeFees(address user) public view returns (uint256) {
return unstakeFees[currentCycle() - stakers[user].stakeCycle > unstakeFeesLength ? unstakeFeesLength - 1 : currentCycle() - stakers[user].stakeCycle];
}
// PUBLIC FUNCTIONS
function stake(uint256 amount, bool isAdding) external {
require(paused == false, "STAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "STAKE: You are blacklisted");
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee) / 10000;
if (stakers[msg.sender].amount == 0 || isAdding) {
amountAfterFees = stakers[msg.sender].unstakeCycle == currentCycle() ? amount.sub(feesAmount) : amountStaked[msg.sender][currentCycle()].add(amount.sub(feesAmount));
require(amountAfterFees.add(stakers[msg.sender].amount) >= minStake, "STAKE: Below min amount");
require(amountAfterFees.add(stakers[msg.sender].amount) <= maxStake, "STAKE: Above max amount");
PLAYMATES.transferFrom(msg.sender, address(this), amount);
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(stakeDistribution[0]) / 10000);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]) / 10000);
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
amountAfterFees = stakers[msg.sender].amount;
}
stakers[msg.sender] = Stake({
stakeCycle: stakers[msg.sender].stakeCycle == 0 ? currentCycle() : stakers[msg.sender].stakeCycle,
lastClaimCycle: stakers[msg.sender].lastClaimCycle == 0 ? currentCycle() : stakers[msg.sender].lastClaimCycle,
unstakeCycle: 0,
amount: amountAfterFees,
totalRewards: stakers[msg.sender].totalRewards
});
if (isAdding) totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
amountStaked[msg.sender][currentCycle()] = amountAfterFees;
totalStaked[currentCycle()] += amountAfterFees;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Staked(msg.sender, amountAfterFees);
}
function claimAll() public {
require(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
uint256 sum = 0;
for(uint256 i = stakers[msg.sender].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[msg.sender][i] == false && stakedDuringCycle[msg.sender][i] == true) {
uint256 share = getShareOf(msg.sender, i);
sum += payouts[i].mul(share) / 10000;
payoutClaimed[msg.sender][i] = true;
}
}
require(sum > 0, "CLAIM4: Nothing to claim");
stakers[msg.sender].lastClaimCycle = currentCycle();
stakers[msg.sender].totalRewards += sum;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function claim(uint256 cycle) public {
require(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
require(payoutClaimed[msg.sender][cycle] == false, "CLAIM4: Nothing to claim");
require(stakedDuringCycle[msg.sender][cycle] == true, "CLAIM6: You unstaked");
uint256 share = getShareOf(msg.sender, cycle);
uint256 sum = payouts[cycle].mul(share) / 10000;
require(sum > 0, "CLAIM5: Nothing to claim");
stakers[msg.sender].lastClaimCycle = cycle;
stakers[msg.sender].totalRewards += sum;
payoutClaimed[msg.sender][cycle] = true;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function unstake(bool bypassClaimAll) external {
require(paused == false, "UNSTAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "UNSTAKE: You are blacklisted");
require(stakers[msg.sender].amount > 0, "UNSTAKE: You have nothing to unstake.");
if (getAllRewardsOf(msg.sender) > 0 && bypassClaimAll == false) {
claimAll();
}
uint256 feesRatio = getUnstakeFees(msg.sender);
uint256 feesAmount = stakers[msg.sender].amount.mul(feesRatio) / 10000;
uint256 amountAfterFees = stakers[msg.sender].amount.sub(feesAmount);
stakers[msg.sender].amount = 0;
stakers[msg.sender].stakeCycle = 0;
stakers[msg.sender].unstakeCycle = currentCycle();
totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
stakedDuringCycle[msg.sender][currentCycle()] = false;
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(unstakeDistribution[0]) / 10000);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(unstakeDistribution[1]) / 10000);
PLAYMATES.transfer(TREASURY, feesAmount.mul(unstakeDistribution[2]) / 10000);
PLAYMATES.transfer(MARKETING, feesAmount.mul(unstakeDistribution[3]) / 10000);
PLAYMATES.transfer(msg.sender, amountAfterFees);
emit Unstaked(msg.sender, amountAfterFees);
}
// ONLY OWNER FUNCTIONS
function setPaused(bool _val) external onlyOwner {
paused = _val;
}
function setPayout(uint256 cycle, uint256 amount) external onlyOwner {
payouts[cycle] = amount;
}
function setBlacklisted(address user, bool _val) external onlyOwner {
blacklist[user] = _val;
}
function setBaseUri(string memory _baseUri) external onlyOwner {
baseUri = _baseUri;
}
function setPlaymates(address _PLAYMATES) external onlyOwner {
PLAYMATES = IERC20(_PLAYMATES);
}
function setPaymentToken(address _PAYMENT_TOKEN) external onlyOwner {
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
}
function setPool(address _POOL) external onlyOwner {
POOL = _POOL;
}
function setTreasury(address _TREASURY) external onlyOwner {
TREASURY = _TREASURY;
}
function setMarketing(address _MARKETING) external onlyOwner {
MARKETING = _MARKETING;
}
function setStakeDistribution(uint256[] memory _stakeDistribution) external onlyOwner {
stakeDistribution = _stakeDistribution;
}
function setUnstakeDistribution(uint256[] memory _unstakeDistribution) external onlyOwner {
unstakeDistribution = _unstakeDistribution;
}
function setCycleDuration(uint256 _cycleDuration) external onlyOwner {
cycleDuration = _cycleDuration;
}
function setStakeFee(uint256 _stakeFee) external onlyOwner {
stakeFee = _stakeFee;
}
function setUnstakeFees(uint256[] memory _unstakeFees, uint256 _unstakeFeesLength) external onlyOwner {
unstakeFees = _unstakeFees;
unstakeFeesLength = _unstakeFeesLength;
}
function setMinStakeAndMaxStake(uint256 _minStake, uint256 _maxStake) external onlyOwner {
minStake = _minStake * 10**16;
maxStake = _maxStake * 10**16;
}
function withdrawPlaymates() external onlyOwner {
PLAYMATES.transfer(msg.sender, PLAYMATES.balanceOf(address(this)));
}
function withdrawPayment() external onlyOwner {
PAYMENT_TOKEN.transfer(msg.sender, PAYMENT_TOKEN.balanceOf(address(this)));
}
}
| 90,627 | 13,022 |
ea9ea4e2ce2f68545a7ed8658fff48debd4714f5b87309f2000d2a312548268b
| 13,321 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/transactionOrderDependancy/manualCheck/0xed93a0bf115382bde967b7ded2f06c692b71634e_TOD.sol
| 3,745 | 11,181 |
pragma solidity ^0.5.13;
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 Callable {
function tokenCallback(address _from, uint256 _tokens, bytes calldata _data) external returns (bool);
}
contract ANULNetwork {
using SafeMath for uint256;
uint256 constant private FLOAT_SCALAR = 2**64;
uint256 constant private INITIAL_SUPPLY = 21000000e18;
uint256 constant private MIN_STAKE_AMOUNT = 1e21; // 1,000 Tokens Needed
uint256 private XFER_FEE = 5; // 5% per tx
uint256 private POOL_FEE = 3; // 3% to pool
uint256 private DESTRUCTION = 2; // 2% to Destruction
uint256 private SHARE_DIVIDENDS = 6; // 25% every collect
uint256 private BASE_PROFIT = 5; // 1% Base Prifit
uint256 private MAX_UNSTAKE_LIMIT = 2592000;
string constant public name = "Annular Network";
string constant public symbol = "ANUL";
uint8 constant public decimals = 18;
struct User {
uint256 balance;
uint256 staked;
mapping(address => uint256) allowance;
uint collectTime;
uint stakeTime;
int256 scaledPayout;
}
struct Info {
uint256 totalSupply;
uint256 totalStaked;
uint256 totalStake;
mapping(address => User) users;
uint256 scaledPayoutPerToken;
address admin;
}
Info private info;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed owner, address indexed spender, uint256 tokens);
event Stake(address indexed owner, uint256 tokens);
event Unstake(address indexed owner, uint256 tokens);
event Collect(address indexed owner, uint256 tokens);
event Tax(uint256 tokens);
constructor() public {
info.admin = msg.sender;
info.totalSupply = INITIAL_SUPPLY;
info.users[msg.sender].balance = INITIAL_SUPPLY;
emit Transfer(address(0x0), msg.sender, INITIAL_SUPPLY);
}
function SetXferFee(uint256 newXferFee) public {
require(msg.sender == info.admin);
require(newXferFee <= 10);
XFER_FEE = newXferFee;
}
function SetPoolFee(uint256 newPoolFee) public {
require(msg.sender == info.admin);
require(XFER_FEE >= newPoolFee);
POOL_FEE = newPoolFee;
}
function SetDestruction(uint256 newDestruction) public {
require(msg.sender == info.admin);
require(XFER_FEE >= newDestruction);
DESTRUCTION = newDestruction;
}
function SetShareDividends(uint256 newShareDividends) public {
require(msg.sender == info.admin);
require(newShareDividends < 100);
SHARE_DIVIDENDS = newShareDividends;
}
function SetBaseProfit(uint256 newBaseProfit) public {
require(msg.sender == info.admin);
require(newBaseProfit < 10);
BASE_PROFIT = newBaseProfit;
}
function SetMaxUnStakeLimit(uint256 newMaxUnStakeLimit) public {
require(msg.sender == info.admin);
require(newMaxUnStakeLimit < 8640000);
MAX_UNSTAKE_LIMIT = newMaxUnStakeLimit;
}
function stake(uint256 _tokens) external {
_stake(_tokens);
}
function unstake(uint256 _tokens) external {
_unstake(_tokens);
}
function collect() external returns (uint256) {
uint256 _dividends = dividendsOf(msg.sender);
require(_dividends > 0);
require(info.users[msg.sender].collectTime < now);
uint256 profit = _dividends.mul(SHARE_DIVIDENDS).div(100);
uint256 base = info.users[msg.sender].staked.mul(BASE_PROFIT).div(100);
info.users[msg.sender].scaledPayout += int256(_dividends.mul(FLOAT_SCALAR).mul(SHARE_DIVIDENDS).div(100));
info.users[msg.sender].balance += profit + base;
info.users[msg.sender].collectTime = now + 86400;
info.totalSupply += base;
emit Transfer(address(this), msg.sender, profit + base);
emit Collect(msg.sender, _dividends);
return _dividends;
}
function reinvest() external returns (uint256) {
uint256 _dividends = dividendsOf(msg.sender);
require(_dividends > 0);
require(info.users[msg.sender].collectTime < now);
uint256 profit = _dividends.mul(SHARE_DIVIDENDS).div(100);
uint256 base = info.users[msg.sender].staked.mul(BASE_PROFIT).div(100);
uint256 _amount = profit + base;
require(balanceOf(msg.sender) >= _amount);
require(stakedOf(msg.sender) + _amount >= MIN_STAKE_AMOUNT);
info.users[msg.sender].scaledPayout += int256(_dividends.mul(FLOAT_SCALAR).mul(SHARE_DIVIDENDS).div(100));
info.users[msg.sender].collectTime = now + 86400;
info.totalSupply += base;
info.totalStaked += _amount;
info.users[msg.sender].staked += _amount;
info.users[msg.sender].scaledPayout += int256(_amount.mul(info.scaledPayoutPerToken));
return _dividends;
}
function distribute(uint256 _tokens) external {
require(info.totalStaked > 0);
require(balanceOf(msg.sender) >= _tokens);
info.users[msg.sender].balance -= _tokens;
info.scaledPayoutPerToken += _tokens.mul(FLOAT_SCALAR).div(info.totalStaked);
emit Transfer(msg.sender, address(this), _tokens);
}
function transfer(address _to, uint256 _tokens) external returns (bool) {
_transfer(msg.sender, _to, _tokens);
return true;
}
function approve(address _spender, uint256 _tokens) external returns (bool) {
info.users[msg.sender].allowance[_spender] = _tokens; //injected TRANSACTION ORDER DEPENDENCE
emit Approval(msg.sender, _spender, _tokens);
return true;
}
function transferFrom(address _from, address _to, uint256 _tokens) external returns (bool) {
require(info.users[_from].allowance[msg.sender] >= _tokens);
info.users[_from].allowance[msg.sender] -= _tokens;
_transfer(_from, _to, _tokens);
return true;
}
function transferAndCall(address _to, uint256 _tokens, bytes calldata _data) external returns (bool) {
uint256 _transferred = _transfer(msg.sender, _to, _tokens);
uint32 _size;
assembly {
_size := extcodesize(_to)
}
if (_size > 0) {
require(Callable(_to).tokenCallback(msg.sender, _transferred, _data));
}
return true;
}
function bulkTransfer(address[] calldata _receivers, uint256[] calldata _amounts) external {
require(_receivers.length == _amounts.length);
for (uint256 i = 0; i < _receivers.length; i++) {
_transfer(msg.sender, _receivers[i], _amounts[i]);
}
}
function totalSupply() public view returns (uint256) {
return info.totalSupply;
}
function totalStaked() public view returns (uint256) {
return info.totalStaked;
}
function balanceOf(address _user) public view returns (uint256) {
return info.users[_user].balance - stakedOf(_user);
}
function stakedOf(address _user) public view returns (uint256) {
return info.users[_user].staked;
}
function unstakeTimeOf(address _user) public view returns (uint256) {
return uint256(int256(info.users[_user].stakeTime + (info.totalSupply - info.totalStaked) * MAX_UNSTAKE_LIMIT / info.totalSupply));
}
function collectTimeOf(address _user) public view returns (uint256) {
return info.users[_user].collectTime;
}
function stakeTimeOf(address _user) public view returns (uint256) {
return info.users[_user].stakeTime;
}
function dividendsOf(address _user) public view returns (uint256) {
return uint256(int256(info.scaledPayoutPerToken * info.users[_user].staked) - info.users[_user].scaledPayout) / FLOAT_SCALAR;
}
function allowance(address _user, address _spender) public view returns (uint256) {
return info.users[_user].allowance[_spender];
}
function allDataFor(address _user) public view returns (uint256 totalTokenSupply, uint256 totalTokensStaked, uint256 userBalance, uint256 userStaked, uint256 userDividends, uint256 userCollectTime, uint256 userUnstakeTime) {
return (totalSupply(), totalStaked(), balanceOf(_user), stakedOf(_user), dividendsOf(_user), collectTimeOf(_user), unstakeTimeOf(_user));
}
function _transfer(address _from, address _to, uint256 _tokens) internal returns (uint256) {
require(balanceOf(_from) >= _tokens);
info.users[_from].balance -= _tokens;
uint256 _taxAmount = _tokens.mul(XFER_FEE).div(100);
uint256 _poolAmount = _tokens.mul(POOL_FEE).div(100);
uint256 _destructionAmount = _tokens.mul(DESTRUCTION).div(100);
uint256 _transferred = _tokens - _taxAmount;
if (info.totalStaked > 0) {
info.users[_to].balance += _transferred;
info.totalSupply = info.totalSupply.sub(_destructionAmount);
emit Transfer(_from, _to, _transferred);
info.scaledPayoutPerToken += _poolAmount.mul(FLOAT_SCALAR).div(info.totalStaked);
emit Transfer(_from, address(this), _poolAmount);
emit Transfer(_from, address(0), _destructionAmount);
emit Tax(_taxAmount);
return _transferred;
} else {
info.users[_to].balance += _tokens;
emit Transfer(_from, _to, _tokens);
return _tokens;
}
}
function _stake(uint256 _amount) internal {
require(balanceOf(msg.sender) >= _amount);
require(stakedOf(msg.sender) + _amount >= MIN_STAKE_AMOUNT);
info.users[msg.sender].stakeTime = now;
info.totalStaked += _amount;
info.users[msg.sender].staked += _amount;
info.users[msg.sender].scaledPayout += int256(_amount.mul(info.scaledPayoutPerToken));
emit Transfer(msg.sender, address(this), _amount);
emit Stake(msg.sender, _amount);
}
function _unstake(uint256 _amount) internal {
require(now > info.users[msg.sender].stakeTime.add(info.totalSupply.sub(info.totalStaked).mul(MAX_UNSTAKE_LIMIT).div(info.totalSupply)));
require(stakedOf(msg.sender) >= _amount);
uint256 _taxAmount = _amount.mul(XFER_FEE).div(100);
info.scaledPayoutPerToken += _taxAmount.mul(FLOAT_SCALAR).div(info.totalStaked);
info.totalStaked -= _amount;
info.users[msg.sender].balance -= _taxAmount;
info.users[msg.sender].staked -= _amount;
info.users[msg.sender].scaledPayout -= int256(_amount.mul(info.scaledPayoutPerToken));
emit Transfer(address(this), msg.sender, _amount.sub(_taxAmount));
emit Unstake(msg.sender, _amount);
}
}
| 277,805 | 13,023 |
42348704295af3021afff520c2ef5a57ae9ff48afac24b18bf90d7bed7fb9569
| 22,594 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x586b3442ccDFCF12a6812B6521FA121448dB9070/contract.sol
| 3,436 | 13,270 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BOOFI is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**8 * 10**6;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 6;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**8 * 10**6;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function LiquidityTX(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**6;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 257,035 | 13,024 |
7b7021b3f8cee845c2dd682b98beefbf1e8ba04b8f2af19d2f7d537fec09eee1
| 25,546 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1cfc329dfce1cea11caeedcbb766078fceaebe55.sol
| 7,628 | 25,284 |
pragma solidity ^0.4.24;
contract owned {
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 ponzimoon is owned {
using SafeMath for uint256;
Spaceship[] spaceships;
Player[] players;
mapping(address => uint256) addressMPid;
mapping(uint256 => address) pidXAddress;
mapping(string => uint256) nameXPid;
uint256 playerCount;
uint256 totalTicketCount;
uint256 airdropPrizePool;
uint256 moonPrizePool;
uint256 lotteryTime;
uint256 editPlayerNamePrice = 0.01 ether;
uint256 spaceshipPrice = 0.01 ether;
uint256 addSpaceshipPrice = 0.00000001 ether;
address maxAirDropAddress;
uint256 maxTotalTicket;
uint256 round;
uint256 totalDividendEarnings;
uint256 totalEarnings;
uint256 luckyPayerId;
struct Spaceship {
uint256 id;
string name;
uint256 speed;
address captain;
uint256 ticketCount;
uint256 dividendRatio;
uint256 spaceshipPrice;
uint256 addSpeed;
}
struct Player {
address addr;
string name;
uint256 earnings;
uint256 ticketCount;
uint256 dividendRatio;
uint256 distributionEarnings;
uint256 dividendEarnings;
uint256 withdrawalAmount;
uint256 parentId;
uint256 dlTicketCount;
uint256 xzTicketCount;
uint256 jcTicketCount;
}
constructor() public {
lotteryTime = now + 12 hours;
round = 1;
spaceships.push(Spaceship(0, "dalao", 100000, msg.sender, 0, 20, 15 ether, 2));
spaceships.push(Spaceship(1, "xiaozhuang", 100000, msg.sender, 0, 50, 15 ether, 5));
spaceships.push(Spaceship(2, "jiucai", 100000, msg.sender, 0, 80, 15 ether, 8));
uint256 playerArrayIndex = players.push(Player(msg.sender, "system", 0, 0, 3, 0, 0, 0, 0, 0, 0, 0));
addressMPid[msg.sender] = playerArrayIndex;
pidXAddress[playerArrayIndex] = msg.sender;
playerCount = players.length;
nameXPid["system"] = playerArrayIndex;
}
function getSpaceship(uint256 _spaceshipId) public view returns (uint256 _id,
string _name,
uint256 _speed,
address _captain,
uint256 _ticketCount,
uint256 _dividendRatio,
uint256 _spaceshipPrice){
_id = spaceships[_spaceshipId].id;
_name = spaceships[_spaceshipId].name;
_speed = spaceships[_spaceshipId].speed;
_captain = spaceships[_spaceshipId].captain;
_ticketCount = spaceships[_spaceshipId].ticketCount;
_dividendRatio = spaceships[_spaceshipId].dividendRatio;
_spaceshipPrice = spaceships[_spaceshipId].spaceshipPrice;
}
function getNowTime() public view returns (uint256){
return now;
}
function checkName(string _name) public view returns (bool){
if (nameXPid[_name] == 0) {
return false;
}
return true;
}
function setYxName(address _address, string _name) external onlyOwner {
if (addressMPid[_address] == 0) {
uint256 playerArrayIndex = players.push(Player(_address, _name, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[_address] = playerArrayIndex;
pidXAddress[playerArrayIndex] = _address;
playerCount = players.length;
nameXPid[_name] = playerArrayIndex;
} else {
uint256 _pid = addressMPid[_address];
Player storage _p = players[_pid.sub(1)];
_p.name = _name;
nameXPid[_name] = _pid;
}
}
function setName(string _name) external payable {
require(msg.value >= editPlayerNamePrice);
if (addressMPid[msg.sender] == 0) {
uint256 playerArrayIndex = players.push(Player(msg.sender, _name, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[msg.sender] = playerArrayIndex;
pidXAddress[playerArrayIndex] = msg.sender;
playerCount = players.length;
nameXPid[_name] = playerArrayIndex;
} else {
uint256 _pid = addressMPid[msg.sender];
Player storage _p = players[_pid.sub(1)];
_p.name = _name;
nameXPid[_name] = _pid;
}
Player storage _sysP = players[0];
_sysP.earnings = _sysP.earnings.add(msg.value);
_sysP.distributionEarnings = _sysP.distributionEarnings.add(msg.value);
}
function _computePayMoney(uint256 _ticketCount, address _addr) private view returns (bool){
uint256 _initMoney = 0.01 ether;
uint256 _eachMoney = 0.0001 ether;
uint256 _payMoney = (spaceshipPrice.mul(_ticketCount)).add(addSpaceshipPrice.mul((_ticketCount.sub(1))));
_payMoney = _payMoney.sub((_eachMoney.mul(_ticketCount)));
uint256 _tmpPid = addressMPid[_addr];
Player memory _p = players[_tmpPid.sub(1)];
if (_p.earnings >= (_initMoney.mul(_ticketCount)) && _p.earnings >= _payMoney) {
return true;
}
return false;
}
function checkTicket(uint256 _ticketCount, uint256 _money) private view returns (bool){
uint256 _initMoney = 0.01 ether;
uint256 _eachMoney = 0.0001 ether;
uint256 _payMoney = (spaceshipPrice.mul(_ticketCount)).add(addSpaceshipPrice.mul((_ticketCount.sub(1))));
_payMoney = _payMoney.sub((_eachMoney.mul(_ticketCount)));
if (_money >= (_initMoney.mul(_ticketCount)) && _money >= _payMoney) {
return true;
}
return false;
}
function checkNewPlayer(address _player) private {
if (addressMPid[_player] == 0) {
uint256 playerArrayIndex = players.push(Player(_player, "", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[_player] = playerArrayIndex;
pidXAddress[playerArrayIndex] = _player;
playerCount = players.length;
}
}
function addTicket(uint256 _ticketCount, uint256 _spaceshipNo, uint256 _pid) private {
spaceshipPrice = spaceshipPrice.add(addSpaceshipPrice.mul(_ticketCount));
totalTicketCount = totalTicketCount.add(_ticketCount);
Player storage _p = players[_pid.sub(1)];
_p.ticketCount = _p.ticketCount.add(_ticketCount);
if (_spaceshipNo == 0) {
_p.dlTicketCount = _p.dlTicketCount.add(_ticketCount);
Spaceship storage _s = spaceships[0];
_s.ticketCount = _s.ticketCount.add(_ticketCount);
_s.speed = _s.speed.add(_ticketCount.mul(_s.addSpeed));
}
if (_spaceshipNo == 1) {
_p.xzTicketCount = _p.xzTicketCount.add(_ticketCount);
Spaceship storage _s1 = spaceships[1];
_s1.ticketCount = _s1.ticketCount.add(_ticketCount);
_s1.speed = _s1.speed.add(_ticketCount.mul(_s1.addSpeed));
}
if (_spaceshipNo == 2) {
_p.jcTicketCount = _p.jcTicketCount.add(_ticketCount);
Spaceship storage _s2 = spaceships[2];
_s2.ticketCount = _s2.ticketCount.add(_ticketCount);
_s2.speed = _s2.speed.add(_ticketCount.mul(_s2.addSpeed));
}
}
function _payTicketByEarnings(uint256 _ticketCount, address _addr) private returns (uint256){
uint256 _tmpPid = addressMPid[_addr];
Player storage _p = players[_tmpPid.sub(1)];
uint256 _tmpMoney = spaceshipPrice.mul(_ticketCount);
uint256 _tmpMoney2 = addSpaceshipPrice.mul(_ticketCount.sub(1));
uint256 _returnMoney = _tmpMoney.add(_tmpMoney2);
_p.earnings = _p.earnings.sub(_returnMoney);
return _returnMoney;
}
function buyTicketByEarnings(uint256 _ticketCount, uint256 _spaceshipNo, string _name) external {
require(now < lotteryTime);
require(_spaceshipNo == 0 || _spaceshipNo == 1 || _spaceshipNo == 2);
require(addressMPid[msg.sender] != 0);
require(_computePayMoney(_ticketCount, msg.sender));
updateTime();
uint256 _money = _payTicketByEarnings(_ticketCount, msg.sender);
totalEarnings = totalEarnings.add(_money);
Player storage _p = players[addressMPid[msg.sender].sub(1)];
if (_p.parentId == 0 && nameXPid[_name] != 0) {
_p.parentId = nameXPid[_name];
}
luckyPayerId = addressMPid[msg.sender];
addTicket(_ticketCount, _spaceshipNo, addressMPid[msg.sender]);
addSpaceshipMoney(_money.div(100).mul(5));
Player storage _player = players[0];
uint256 _SysMoney = _money.div(100).mul(3);
_player.earnings = _player.earnings.add(_SysMoney);
_player.dividendEarnings = _player.dividendEarnings.add(_SysMoney);
uint256 _distributionMoney = _money.div(100).mul(10);
if (_p.parentId == 0) {
_player.earnings = _player.earnings.add(_distributionMoney);
_player.distributionEarnings = _player.distributionEarnings.add(_distributionMoney);
} else {
Player storage _player_ = players[_p.parentId.sub(1)];
_player_.earnings = _player_.earnings.add(_distributionMoney);
_player_.distributionEarnings = _player_.distributionEarnings.add(_distributionMoney);
}
if (_ticketCount > maxTotalTicket) {
maxTotalTicket = _ticketCount;
maxAirDropAddress = msg.sender;
}
uint256 _airDropMoney = _money.div(100).mul(2);
airdropPrizePool = airdropPrizePool.add(_airDropMoney);
if (airdropPrizePool >= 1 ether) {
Player storage _playerAirdrop = players[addressMPid[maxAirDropAddress].sub(1)];
_playerAirdrop.earnings = _playerAirdrop.earnings.add(airdropPrizePool);
_playerAirdrop.dividendEarnings = _playerAirdrop.dividendEarnings.add(airdropPrizePool);
airdropPrizePool = 0;
}
uint256 _remainderMoney = _cMoney(_money, _SysMoney, _distributionMoney, _airDropMoney);
updateGameMoney(_remainderMoney, _spaceshipNo, _ticketCount, addressMPid[msg.sender].sub(1));
}
function _cMoney(uint256 _money, uint256 _SysMoney, uint256 _distributionMoney, uint256 _airDropMoney)
private pure returns (uint256){
uint256 _czSpaceshipMoney = _money.div(100).mul(5).mul(3);
return _money.sub(_czSpaceshipMoney).sub(_SysMoney).
sub(_distributionMoney).sub(_airDropMoney);
}
function updateTime() private {
if (totalTicketCount < 50000) {
lotteryTime = now + 12 hours;
} else {
lotteryTime = now + 1 hours;
}
}
function buyTicket(uint256 _ticketCount, uint256 _spaceshipNo, string _name) external payable {
require(now < lotteryTime);
require(_spaceshipNo == 0 || _spaceshipNo == 1 || _spaceshipNo == 2);
require(checkTicket(_ticketCount, msg.value));
checkNewPlayer(msg.sender);
updateTime();
totalEarnings = totalEarnings.add(msg.value);
Player storage _p = players[addressMPid[msg.sender].sub(1)];
if (_p.parentId == 0 && nameXPid[_name] != 0) {
_p.parentId = nameXPid[_name];
}
luckyPayerId = addressMPid[msg.sender];
addTicket(_ticketCount, _spaceshipNo, addressMPid[msg.sender]);
addSpaceshipMoney(msg.value.div(100).mul(5));
Player storage _player = players[0];
uint256 _SysMoney = msg.value.div(100).mul(3);
_player.earnings = _player.earnings.add(_SysMoney);
_player.dividendEarnings = _player.dividendEarnings.add(_SysMoney);
uint256 _distributionMoney = msg.value.div(100).mul(10);
if (_p.parentId == 0) {
_player.earnings = _player.earnings.add(_distributionMoney);
_player.distributionEarnings = _player.distributionEarnings.add(_distributionMoney);
} else {
Player storage _player_ = players[_p.parentId.sub(1)];
_player_.earnings = _player_.earnings.add(_distributionMoney);
_player_.distributionEarnings = _player_.distributionEarnings.add(_distributionMoney);
}
if (_ticketCount > maxTotalTicket) {
maxTotalTicket = _ticketCount;
maxAirDropAddress = msg.sender;
}
uint256 _airDropMoney = msg.value.div(100).mul(2);
airdropPrizePool = airdropPrizePool.add(_airDropMoney);
if (airdropPrizePool >= 1 ether) {
Player storage _playerAirdrop = players[addressMPid[maxAirDropAddress].sub(1)];
_playerAirdrop.earnings = _playerAirdrop.earnings.add(airdropPrizePool);
_playerAirdrop.dividendEarnings = _playerAirdrop.dividendEarnings.add(airdropPrizePool);
airdropPrizePool = 0;
}
uint256 _remainderMoney = msg.value.sub((msg.value.div(100).mul(5)).mul(3)).sub(_SysMoney).
sub(_distributionMoney).sub(_airDropMoney);
updateGameMoney(_remainderMoney, _spaceshipNo, _ticketCount, addressMPid[msg.sender].sub(1));
}
function getFhMoney(uint256 _spaceshipNo, uint256 _money, uint256 _ticketCount, uint256 _targetNo) private view returns (uint256){
Spaceship memory _fc = spaceships[_spaceshipNo];
if (_spaceshipNo == _targetNo) {
uint256 _Ticket = _fc.ticketCount.sub(_ticketCount);
if (_Ticket == 0) {
return 0;
}
return _money.div(_Ticket);
} else {
if (_fc.ticketCount == 0) {
return 0;
}
return _money.div(_fc.ticketCount);
}
}
function updateGameMoney(uint256 _money, uint256 _spaceshipNo, uint256 _ticketCount, uint256 _arrayPid) private {
uint256 _lastMoney = addMoonPrizePool(_money, _spaceshipNo);
uint256 _dlMoney = _lastMoney.div(100).mul(53);
uint256 _xzMoney = _lastMoney.div(100).mul(33);
uint256 _jcMoney = _lastMoney.sub(_dlMoney).sub(_xzMoney);
uint256 _dlFMoney = getFhMoney(0, _dlMoney, _ticketCount, _spaceshipNo);
uint256 _xzFMoney = getFhMoney(1, _xzMoney, _ticketCount, _spaceshipNo);
uint256 _jcFMoney = getFhMoney(2, _jcMoney, _ticketCount, _spaceshipNo);
_fhMoney(_dlFMoney, _xzFMoney, _jcFMoney, _arrayPid, _spaceshipNo, _ticketCount);
}
function _fhMoney(uint256 _dlFMoney, uint256 _xzFMoney, uint256 _jcFMoney, uint256 arrayPid, uint256 _spaceshipNo, uint256 _ticketCount) private {
for (uint i = 0; i < players.length; i++) {
Player storage _tmpP = players[i];
uint256 _totalMoney = 0;
if (arrayPid != i) {
_totalMoney = _totalMoney.add(_tmpP.dlTicketCount.mul(_dlFMoney));
_totalMoney = _totalMoney.add(_tmpP.xzTicketCount.mul(_xzFMoney));
_totalMoney = _totalMoney.add(_tmpP.jcTicketCount.mul(_jcFMoney));
} else {
if (_spaceshipNo == 0) {
_totalMoney = _totalMoney.add((_tmpP.dlTicketCount.sub(_ticketCount)).mul(_dlFMoney));
} else {
_totalMoney = _totalMoney.add(_tmpP.dlTicketCount.mul(_dlFMoney));
}
if (_spaceshipNo == 1) {
_totalMoney = _totalMoney.add((_tmpP.xzTicketCount.sub(_ticketCount)).mul(_xzFMoney));
} else {
_totalMoney = _totalMoney.add(_tmpP.xzTicketCount.mul(_xzFMoney));
}
if (_spaceshipNo == 2) {
_totalMoney = _totalMoney.add((_tmpP.jcTicketCount.sub(_ticketCount)).mul(_jcFMoney));
} else {
_totalMoney = _totalMoney.add(_tmpP.jcTicketCount.mul(_jcFMoney));
}
}
_tmpP.earnings = _tmpP.earnings.add(_totalMoney);
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_totalMoney);
}
}
function addMoonPrizePool(uint256 _money, uint256 _spaceshipNo) private returns (uint){
uint256 _tmpMoney;
if (_spaceshipNo == 0) {
_tmpMoney = _money.div(100).mul(80);
totalDividendEarnings = totalDividendEarnings.add((_money.sub(_tmpMoney)));
}
if (_spaceshipNo == 1) {
_tmpMoney = _money.div(100).mul(50);
totalDividendEarnings = totalDividendEarnings.add((_money.sub(_tmpMoney)));
}
if (_spaceshipNo == 2) {
_tmpMoney = _money.div(100).mul(20);
totalDividendEarnings = totalDividendEarnings.add((_money.sub(_tmpMoney)));
}
moonPrizePool = moonPrizePool.add(_tmpMoney);
return _money.sub(_tmpMoney);
}
function addSpaceshipMoney(uint256 _money) internal {
Spaceship storage _spaceship0 = spaceships[0];
uint256 _pid0 = addressMPid[_spaceship0.captain];
Player storage _player0 = players[_pid0.sub(1)];
_player0.earnings = _player0.earnings.add(_money);
_player0.dividendEarnings = _player0.dividendEarnings.add(_money);
Spaceship storage _spaceship1 = spaceships[1];
uint256 _pid1 = addressMPid[_spaceship1.captain];
Player storage _player1 = players[_pid1.sub(1)];
_player1.earnings = _player1.earnings.add(_money);
_player1.dividendEarnings = _player1.dividendEarnings.add(_money);
Spaceship storage _spaceship2 = spaceships[2];
uint256 _pid2 = addressMPid[_spaceship2.captain];
Player storage _player2 = players[_pid2.sub(1)];
_player2.earnings = _player2.earnings.add(_money);
_player2.dividendEarnings = _player2.dividendEarnings.add(_money);
}
function getPlayerInfo(address _playerAddress) public view returns (address _addr,
string _name,
uint256 _earnings,
uint256 _ticketCount,
uint256 _dividendEarnings,
uint256 _distributionEarnings,
uint256 _dlTicketCount,
uint256 _xzTicketCount,
uint256 _jcTicketCount){
uint256 _pid = addressMPid[_playerAddress];
Player storage _player = players[_pid.sub(1)];
_addr = _player.addr;
_name = _player.name;
_earnings = _player.earnings;
_ticketCount = _player.ticketCount;
_dividendEarnings = _player.dividendEarnings;
_distributionEarnings = _player.distributionEarnings;
_dlTicketCount = _player.dlTicketCount;
_xzTicketCount = _player.xzTicketCount;
_jcTicketCount = _player.jcTicketCount;
}
function addSystemUserEarnings(uint256 _money) private {
Player storage _player = players[0];
_player.earnings = _player.earnings.add(_money);
}
function withdraw() public {
require(addressMPid[msg.sender] != 0);
Player storage _player = players[addressMPid[msg.sender].sub(1)];
_player.addr.transfer(_player.earnings);
_player.withdrawalAmount = _player.withdrawalAmount.add(_player.earnings);
_player.earnings = 0;
_player.distributionEarnings = 0;
_player.dividendEarnings = 0;
}
function makeMoney() public {
require(now > lotteryTime);
moonPrizePool = moonPrizePool.add(airdropPrizePool);
uint256 _pMoney = moonPrizePool.div(2);
Player storage _luckyPayer = players[luckyPayerId.sub(1)];
_luckyPayer.earnings = _luckyPayer.earnings.add(_pMoney);
uint256 _nextMoonPrizePool = moonPrizePool.div(100).mul(2);
uint256 _luckyCaptainMoney = moonPrizePool.div(100).mul(5);
uint256 _luckyCrewMoney = moonPrizePool.sub(_nextMoonPrizePool).sub(_luckyCaptainMoney).sub(_pMoney);
uint256 _no1Spaceship = getFastestSpaceship();
Spaceship storage _s = spaceships[_no1Spaceship];
uint256 _pid = addressMPid[_s.captain];
Player storage _pPayer = players[_pid.sub(1)];
_pPayer.earnings = _pPayer.earnings.add(_luckyCaptainMoney);
uint256 _eachMoney = _getLuckySpaceshipMoney(_no1Spaceship, _luckyCrewMoney);
for (uint i = 0; i < players.length; i++) {
Player storage _tmpP = players[i];
if (_no1Spaceship == 0) {
_tmpP.earnings = _tmpP.earnings.add(_tmpP.dlTicketCount.mul(_eachMoney));
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_tmpP.dlTicketCount.mul(_eachMoney));
}
if (_no1Spaceship == 1) {
_tmpP.earnings = _tmpP.earnings.add(_tmpP.xzTicketCount.mul(_eachMoney));
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_tmpP.xzTicketCount.mul(_eachMoney));
}
if (_no1Spaceship == 2) {
_tmpP.earnings = _tmpP.earnings.add(_tmpP.jcTicketCount.mul(_eachMoney));
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_tmpP.jcTicketCount.mul(_eachMoney));
}
_tmpP.dlTicketCount = 0;
_tmpP.xzTicketCount = 0;
_tmpP.jcTicketCount = 0;
_tmpP.ticketCount = 0;
}
_initSpaceship();
totalTicketCount = 0;
airdropPrizePool = 0;
moonPrizePool = _nextMoonPrizePool;
lotteryTime = now + 12 hours;
spaceshipPrice = 0.01 ether;
maxAirDropAddress = pidXAddress[1];
maxTotalTicket = 0;
round = round.add(1);
luckyPayerId = 1;
}
function _initSpaceship() private {
for (uint i = 0; i < spaceships.length; i++) {
Spaceship storage _s = spaceships[i];
_s.captain = pidXAddress[1];
_s.ticketCount = 0;
_s.spaceshipPrice = 15 ether;
_s.speed = 100000;
}
}
function _getLuckySpaceshipMoney(uint256 _spaceshipId, uint256 _luckyMoney) private view returns (uint256){
Spaceship memory _s = spaceships[_spaceshipId];
uint256 _eachLuckyMoney = _luckyMoney.div(_s.ticketCount);
return _eachLuckyMoney;
}
function getFastestSpaceship() private view returns (uint256){
Spaceship memory _dlSpaceship = spaceships[0];
Spaceship memory _xzSpaceship = spaceships[1];
Spaceship memory _jcSpaceship = spaceships[2];
uint256 _maxSpeed;
if (_jcSpaceship.speed >= _xzSpaceship.speed) {
if (_jcSpaceship.speed >= _dlSpaceship.speed) {
_maxSpeed = 2;
} else {
_maxSpeed = 0;
}
} else {
if (_xzSpaceship.speed >= _dlSpaceship.speed) {
_maxSpeed = 1;
} else {
_maxSpeed = 0;
}
}
return _maxSpeed;
}
function getGameInfo() public view returns (uint256 _totalTicketCount,
uint256 _airdropPrizePool,
uint256 _moonPrizePool,
uint256 _lotteryTime,
uint256 _nowTime,
uint256 _spaceshipPrice,
uint256 _round,
uint256 _totalEarnings,
uint256 _totalDividendEarnings){
_totalTicketCount = totalTicketCount;
_airdropPrizePool = airdropPrizePool;
_moonPrizePool = moonPrizePool;
_lotteryTime = lotteryTime;
_nowTime = now;
_spaceshipPrice = spaceshipPrice;
_round = round;
_totalEarnings = totalEarnings;
_totalDividendEarnings = totalDividendEarnings;
}
function _updateSpaceshipPrice(uint256 _spaceshipId) internal {
spaceships[_spaceshipId].spaceshipPrice = spaceships[_spaceshipId].spaceshipPrice.add(spaceships[_spaceshipId].spaceshipPrice.mul(3).div(10));
}
function campaignCaptain(uint _spaceshipId) external payable {
require(now < lotteryTime);
require(msg.value == spaceships[_spaceshipId].spaceshipPrice);
if (addressMPid[msg.sender] == 0) {
uint256 playerArrayIndex = players.push(Player(msg.sender, "", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[msg.sender] = playerArrayIndex;
pidXAddress[playerArrayIndex] = msg.sender;
playerCount = players.length;
}
spaceships[_spaceshipId].captain.transfer(msg.value);
spaceships[_spaceshipId].captain = msg.sender;
_updateSpaceshipPrice(_spaceshipId);
}
}
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);
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;
}
}
| 166,871 | 13,025 |
f8c4d401bc26cfb06e80bb17008efa5bdceadf64496f6e4ab9c90d54f3bedb03
| 31,755 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/0a/0a5C377936e85E0016FD5768bf97885aD24cea27_Boardroom.sol
| 4,784 | 18,549 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// Part: Address
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);
}
}
}
}
// Part: ContractGuard
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
// Part: IERC20
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);
}
// Part: ITreasury
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getSkullPrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
// Part: SafeMath
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;
}
}
// Part: SafeERC20
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");
}
}
}
// Part: ShareWrapper
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 memberShare = _balances[msg.sender];
require(memberShare >= amount, "Boardroom: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = memberShare.sub(amount);
share.safeTransfer(msg.sender, amount); //Uses msg.sender for the from address
}
}
// File: Boardroom.sol
contract Boardroom is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Memberseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct BoardroomSnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public skull;
ITreasury public treasury;
mapping(address => Memberseat) public members;
BoardroomSnapshot[] public boardroomHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Boardroom: caller is not the operator");
_;
}
modifier memberExists() {
require(balanceOf(msg.sender) > 0, "Boardroom: The member does not exist");
_;
}
modifier updateReward(address member) {
if (member != address(0)) {
Memberseat memory seat = members[member];
seat.rewardEarned = earned(member);
seat.lastSnapshotIndex = latestSnapshotIndex();
members[member] = seat;
}
_;
}
modifier notInitialized() {
require(!initialized, "Boardroom: already initialized");
_;
}
function initialize(IERC20 _skull,
IERC20 _share,
ITreasury _treasury) public notInitialized {
skull = _skull;
share = _share;
treasury = _treasury;
BoardroomSnapshot memory genesisSnapshot = BoardroomSnapshot({time: block.number, rewardReceived: 0, rewardPerShare: 0});
boardroomHistory.push(genesisSnapshot);
withdrawLockupEpochs = 4; // Lock for 4 epochs (24h) before release withdraw
rewardLockupEpochs = 2; // Lock for 2 epochs (12h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return boardroomHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (BoardroomSnapshot memory) {
return boardroomHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address member) public view returns (uint256) {
return members[member].lastSnapshotIndex;
}
function getLastSnapshotOf(address member) internal view returns (BoardroomSnapshot memory) {
return boardroomHistory[getLastSnapshotIndexOf(member)];
}
function canWithdraw(address member) external view returns (bool) {
return members[member].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address member) external view returns (bool) {
return members[member].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getSkullPrice() external view returns (uint256) {
return treasury.getSkullPrice();
}
// =========== Member getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address member) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(member).rewardPerShare;
return balanceOf(member).mul(latestRPS.sub(storedRPS)).div(1e18).add(members[member].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Boardroom: Cannot stake 0");
super.stake(amount);
members[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock memberExists updateReward(msg.sender) {
require(amount > 0, "Boardroom: Cannot withdraw 0");
require(members[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Boardroom: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = members[msg.sender].rewardEarned;
if (reward > 0) {
require(members[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Boardroom: still in reward lockup");
members[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
members[msg.sender].rewardEarned = 0;
skull.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Boardroom: Cannot allocate 0");
require(totalSupply() > 0, "Boardroom: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
BoardroomSnapshot memory newSnapshot = BoardroomSnapshot({time: block.number, rewardReceived: amount, rewardPerShare: nextRPS});
boardroomHistory.push(newSnapshot);
skull.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 _amount,
address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(skull), "skull");
require(address(_token) != address(share), "share");
_token.safeTransfer(_to, _amount);
}
}
| 324,520 | 13,026 |
ffd190e59390549ac22d812901cf4a985616bf20f58d27da396e9980db8662d6
| 15,556 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/2276_39654_0x44d771d0c998f524ff39ab6df64b72bce1d09566.sol
| 2,926 | 11,324 |
pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public 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);
}
contract YfDAIstaking is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// yfdai token contract address
address public constant tokenAddress = 0xf4CD3d3Fda8d7Fd6C5a500203e38640A70Bf9577;
// reward rate 72.00% per year
uint public constant rewardRate = 7200;
uint public constant rewardInterval = 365 days;
// staking fee 1.50 percent
uint public constant stakingFeeRate = 150;
// unstaking fee 0.50 percent
uint public constant unstakingFeeRate = 50;
// unstaking possible after 72 hours
uint public constant cliffTime = 72 hours;
uint public totalClaimedRewards = 0;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
function updateAccount(address account) private {
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
require(Token(tokenAddress).transfer(account, pendingDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
emit RewardsTransferred(account, pendingDivs);
}
lastClaimedTime[account] = now;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint timeDiff = now.sub(lastClaimedTime[_holder]);
uint stakedAmount = depositedTokens[_holder];
uint pendingDivs = stakedAmount
.mul(rewardRate)
.mul(timeDiff)
.div(rewardInterval)
.div(1e4);
return pendingDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function deposit(uint amountToStake) public {
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(Token(tokenAddress).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
uint fee = amountToStake.mul(stakingFeeRate).div(1e4);
uint amountAfterFee = amountToStake.sub(fee);
require(Token(tokenAddress).transfer(owner, fee), "Could not transfer deposit fee.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = now;
}
}
function withdraw(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(stakingTime[msg.sender]) > cliffTime, "You recently staked, please wait before withdrawing.");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(unstakingFeeRate).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(tokenAddress).transfer(owner, fee), "Could not transfer withdraw fee.");
require(Token(tokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claimDivs() public {
updateAccount(msg.sender);
}
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);
}
uint private constant stakingAndDaoTokens = 5129e18;
function getStakingAndDaoAmount() public view returns (uint) {
if (totalClaimedRewards >= stakingAndDaoTokens) {
return 0;
}
uint remaining = stakingAndDaoTokens.sub(totalClaimedRewards);
return remaining;
}
// function to allow admin to claim *other* ERC20 tokens sent to this contract (by mistake)
// Admin cannot transfer out YF-DAI from this smart contract
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
require (_tokenAddr != tokenAddress, "Cannot Transfer Out YF-DAI!");
Token(_tokenAddr).transfer(_to, _amount);
}
}
| 229,872 | 13,027 |
2db235028844fa3318b2098571dc275637ab65a5221f39656384fad5e3386692
| 32,307 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/9c/9cd9ed959e1419efcd8bd265c5e08dee906c0e78_PrivateSale.sol
| 3,551 | 13,869 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.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) {
// 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);
}
}
}
}
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
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 transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract HasForeignAsset is Ownable {
function assetBalance(IBEP20 asset) external view returns(uint256) {
return asset.balanceOf(address(this));
}
function getAsset(IBEP20 asset) external onlyOwner {
asset.transfer(owner(), this.assetBalance(asset));
}
}
contract Bakerytools is IBEP20, HasForeignAsset {
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;
constructor () {
_name = "Bakerytools";
_symbol = "TBAKE";
_decimals = 18;
uint256 _maxSupply = 100000000;
_mintOnce(msg.sender, _maxSupply.mul(10 ** _decimals));
}
receive() external payable {
revert();
}
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, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(recipient != address(this),"BEP20: Transfer to the same contract address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mintOnce(address account, uint256 amount) internal virtual {
require(account != address(0), "BEP20: 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), "BEP20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
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 _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract PrivateSale is Ownable{
using SafeMath for uint256;
// The token being sold
Bakerytools public token;
// Address where funds are collected
address payable public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
uint256 public _startTime;
uint256 public _endTime;
mapping (address => uint256) tokenHolders;
event TokenPurchase(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(uint256 _rate, address payable _wallet, Bakerytools _token, uint256 startTime, uint256 endTime) {
require(_rate > 0);
require(_wallet != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
_startTime = startTime;
_endTime = endTime;
}
fallback () external payable {
buyTokens(msg.sender);
}
receive () external payable {
buyTokens(msg.sender);
}
modifier hasStarted()
{
require(block.timestamp > _startTime, "Presale has not started yet");
_;
}
modifier hasClosed()
{
require(block.timestamp < _endTime, "Presale has already finished");
_;
}
modifier hasTokens()
{
require (token.balanceOf(address(this)) > 0 , "No tokens left");
_;
}
modifier isVestingFinished()
{
require(block.timestamp > 1622530800, "Vesting period is over");
_; //vesting periods ends at 01-06-2021 12:00 pm
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
uint256 _50Percent = tokens.div(2);
tokenHolders[_beneficiary] = _50Percent;
// update state
weiRaised = weiRaised.add(weiAmount);
_deliverTokens(_beneficiary, _50Percent);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
_50Percent);
_forwardFunds();
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
view internal hasStarted hasClosed hasTokens
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
token.transfer(_beneficiary, _tokenAmount);
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
function withdraw (address withdrawer) public isVestingFinished
{
require(withdrawer != address(0), "BEP20: Transfer to zero address");
uint256 withdrawnAmount = tokenHolders[withdrawer];
_deliverTokens(withdrawer, withdrawnAmount);
}
function sendTokensBack() public onlyOwner hasClosed
{
token.transferFrom(address(this), msg.sender, token.balanceOf(address(this)));
}
}
| 116,464 | 13,028 |
d3b18db11ec5f73edfb00349082c8d008a7a575c236049045c72a8198567c9f3
| 39,016 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/76/76E0ecAbD80Be124a71F5DE3C6599d3503d28de8_NFT.sol
| 4,493 | 18,554 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
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 IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// 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;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
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) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
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) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_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 {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_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 {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library Counters {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
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);
}
}
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);
}
}
abstract contract ERC721URIStorage is ERC721 {
using Strings for uint256;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return _tokenURI;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(_tokenURI).length > 0) {
return string(abi.encodePacked(base, _tokenURI));
}
return super.tokenURI(tokenId);
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
function _burn(uint256 tokenId) internal virtual override {
super._burn(tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
contract NFT is ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
constructor() ERC721("EY-3 TerraFormers", "EY3TF") {}
function mintNFT(address recipient, string memory tokenURI)
public onlyOwner
returns (uint256)
{
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(recipient, newItemId);
_setTokenURI(newItemId, tokenURI);
return newItemId;
}
}
| 315,545 | 13,029 |
87434c8c6c73ab06c9bb0bce7713759d63472d00c51842952dceb14313e3c915
| 18,148 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/7158_11144_0xe65f525ec48c7e95654b9824ecc358454ea9185e.sol
| 4,851 | 16,858 |
pragma solidity ^0.4.25;
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract AceDapp is Ownable{
using SafeMath for uint256;
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "ETH Exchange";
string public symbol = "ATH";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 29;
uint8 constant internal transferFee_ = 1;
uint8 constant internal ExitFee_ = 24;
uint8 constant internal refferalFee_ = 8;
uint8 constant internal DevFee_ = 15;
uint8 constant internal DailyInterest_ = 1;
uint8 constant internal IntFee_ = 35;
uint256 public InterestPool_ = 0;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
address dev = 0xA4d05a1c22C8Abe6CCB2333C092EC80bd0955031;
function buy(address _referredBy) public payable returns (uint256) {
uint256 DevFee1 = msg.value.div(100).mul(DevFee_);
uint256 DevFeeFinal = SafeMath.div(DevFee1, 10);
dev.transfer(DevFeeFinal);
uint256 DailyInt1 = msg.value.div(100).mul(IntFee_);
uint256 DailyIntFinal = SafeMath.div(DailyInt1, 10);
InterestPool_ += DailyIntFinal;
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
uint256 DevFee1 = msg.value.div(100).mul(DevFee_);
uint256 DevFeeFinal = SafeMath.div(DevFee1, 10);
dev.transfer(DevFeeFinal);
uint256 DailyInt1 = msg.value.div(100).mul(IntFee_);
uint256 DailyIntFinal = SafeMath.div(DailyInt1, 10);
InterestPool_ += DailyIntFinal;
purchaseTokens(msg.value, 0x0);
}
function IDD() public {
require(msg.sender==owner);
uint256 Contract_Bal = SafeMath.sub((address(this).balance), InterestPool_);
uint256 DailyInterest1 = SafeMath.div(SafeMath.mul(Contract_Bal, DailyInterest_), 100);
uint256 DailyInterestFinal = SafeMath.div(DailyInterest1, 10);
InterestPool_ -= DailyInterestFinal;
DividendsDistribution(DailyInterestFinal, 0x0);
}
function DivsAddon() public payable returns (uint256) {
DividendsDistribution(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _devexit = SafeMath.div(SafeMath.mul(_ethereum, 5), 100);
uint256 _taxedEthereum1 = SafeMath.sub(_ethereum, _dividends);
uint256 _taxedEthereum = SafeMath.sub(_taxedEthereum1, _devexit);
uint256 _devexitindividual = SafeMath.div(SafeMath.mul(_ethereum, DevFee_), 100);
uint256 _devexitindividual_final = SafeMath.div(_devexitindividual, 10);
uint256 DailyInt1 = SafeMath.div(SafeMath.mul(_ethereum, IntFee_), 100);
uint256 DailyIntFinal = SafeMath.div(DailyInt1, 10);
InterestPool_ += DailyIntFinal;
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
dev.transfer(_devexitindividual_final);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _devexit = SafeMath.div(SafeMath.mul(_ethereum, 5), 100);
uint256 _taxedEthereum1 = SafeMath.sub(_ethereum, _dividends);
uint256 _taxedEthereum = SafeMath.sub(_taxedEthereum1, _devexit);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _devexit = SafeMath.div(SafeMath.mul(_ethereum, 5), 100);
uint256 _taxedEthereum1 = SafeMath.add(_ethereum, _dividends);
uint256 _taxedEthereum = SafeMath.add(_taxedEthereum1, _devexit);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _devbuyfees = SafeMath.div(SafeMath.mul(_ethereumToSpend, 5), 100);
uint256 _taxedEthereum1 = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _taxedEthereum = SafeMath.sub(_taxedEthereum1, _devbuyfees);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _devexit = SafeMath.div(SafeMath.mul(_ethereum, 5), 100);
uint256 _taxedEthereum1 = SafeMath.sub(_ethereum, _dividends);
uint256 _taxedEthereum = SafeMath.sub(_taxedEthereum1, _devexit);
return _taxedEthereum;
}
function exitFee() public view returns (uint8) {
return ExitFee_;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _devbuyfees = SafeMath.div(SafeMath.mul(_incomingEthereum, 5), 100);
uint256 _dividends1 = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _dividends = SafeMath.sub(_dividends1, _devbuyfees);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function DividendsDistribution(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, 100), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens >= 0 && SafeMath.add(_amountOfTokens, tokenSupply_) >= tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 232,153 | 13,030 |
88707d8b8887a64e3077c0963bc630768587627f0fe99964f6eca5bf91f11236
| 21,968 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TULYbUCVUPUt88o4b2qLMETEWn6y2ZK6z5_ASORTSS.sol
| 5,361 | 20,786 |
//SourceUnit: ASORTSS.sol
pragma solidity 0.4.25;
contract ASORTSS {
//User details
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeM1Levels;
mapping(uint8 => bool) activeM2Levels;
mapping(uint8 => M1) m1Matrix;
mapping(uint8 => M2) m2Matrix;
uint256 dividendReceived;
}
// X3 matrix
struct M1 {
address Senior;
address[] Juniors;
bool blocked;
uint reinvestCount;
}
//X4 matrix
struct M2 {
address Senior;
address[] firstLevelJuniors;
address[] secondLevelJuniors;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public userIds;
uint public lastUserId = 4;
address public owner;
//declare prices for each levels
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed Senior, 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, address ID2, address ID3) public {
//sets first level price
levelPrice[1] = 20 trx;
//sets all other levels price by doubling first level prive
levelPrice[2] = 40 trx;
levelPrice[3] = 80 trx;
levelPrice[4] = 160 trx;
levelPrice[5] = 320 trx;
levelPrice[6] = 640 trx;
levelPrice[7] = 1280 trx;
levelPrice[8] = 2560 trx;
levelPrice[9] = 5120 trx;
levelPrice[10] = 10240 trx;
levelPrice[11] = 20480 trx;
levelPrice[12] = 40960 trx;
//sets owner address
owner = ownerAddress;
//Declare first user from struct
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: 2,
dividendReceived:0
});
User memory two = User({
id: 2,
referrer: ownerAddress,
partnersCount: uint(0),
dividendReceived:0
});
User memory three = User({
id: 3,
referrer: ownerAddress,
partnersCount: uint(0),
dividendReceived:0
});
// add first user to users mapping (address to User struct mapping)
users[ownerAddress] = user;
users[ID2] = two;
users[ID3] = three;
users[ownerAddress].m1Matrix[1].Juniors.push(ID2);
users[ownerAddress].m1Matrix[1].Juniors.push(ID3);
users[ownerAddress].m2Matrix[1].firstLevelJuniors.push(ID2);
users[ownerAddress].m2Matrix[1].firstLevelJuniors.push(ID3);
users[ID2].m1Matrix[1].Senior = ownerAddress;
users[ID3].m1Matrix[1].Senior = ownerAddress;
// activate all the levels for x3 and x4 for first user
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeM1Levels[i] = true;
users[ownerAddress].activeM2Levels[i] = true;
users[ID2].activeM1Levels[i] = true;
users[ID2].activeM2Levels[i] = true;
users[ID3].activeM1Levels[i] = true;
users[ID3].activeM2Levels[i] = true;
}
// userIds is mapping from integer to address
userIds[1] = ownerAddress;
userIds[2] = ID2;
userIds[3] = ID3;
}
function registerFirsttime() public payable returns(bool) {
registration(msg.sender, owner);
return true;
}
//registration with referral address
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
//buy level function payament
function buyNewLevel(uint8 matrix, uint8 level) external payable {
//isUserExists is function at line 407 checks if user exists
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
// levelPrice is mapping from integer(level) to integer(price) at line 51
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeM1Levels[level], "level already activated");
if (users[msg.sender].m1Matrix[level-1].blocked) {
users[msg.sender].m1Matrix[level-1].blocked = false;
}
address m1referrer = findm1referrer(msg.sender, level);
//X3 matrix is mapping from integer to X3 struct
users[msg.sender].m1Matrix[level].Senior = m1referrer;
users[msg.sender].activeM1Levels[level] = true;
updateM1referrer(msg.sender, m1referrer, level);
emit Upgrade(msg.sender, m1referrer, 1, level);
} else {
require(!users[msg.sender].activeM2Levels[level], "level already activated");
if (users[msg.sender].m2Matrix[level-1].blocked) {
users[msg.sender].m2Matrix[level-1].blocked = false;
}
address m2referrer = findm2referrer(msg.sender, level);
users[msg.sender].activeM2Levels[level] = true;
updateM2referrer(msg.sender, m2referrer, level);
emit Upgrade(msg.sender, m2referrer, 2, level);
}
}
function findm1referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
// activeM1Levels is mapping integer to bool
// if referrer is already there for User return referrer address
if (users[users[userAddress].referrer].activeM1Levels[level]) {
return users[userAddress].referrer;
}
// else set userAddress as referrer address in User struct
userAddress = users[userAddress].referrer;
}
}
function findm2referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeM2Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveM1Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeM1Levels[level];
}
function usersActiveM2Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeM2Levels[level];
}
function usersM1Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint) {
return (users[userAddress].m1Matrix[level].Senior,
users[userAddress].m1Matrix[level].Juniors,
users[userAddress].m1Matrix[level].blocked,
users[userAddress].m1Matrix[level].reinvestCount);
}
function usersM2Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint) {
return (users[userAddress].m2Matrix[level].Senior,
users[userAddress].m2Matrix[level].firstLevelJuniors,
users[userAddress].m2Matrix[level].secondLevelJuniors,
users[userAddress].m2Matrix[level].blocked,
users[userAddress].m2Matrix[level].reinvestCount);
}
// checks if user exists from users mapping(address to User struct) and id property of User struct
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 50 trx, "registration cost 50 trx");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer does not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
dividendReceived:0
});
users[userAddress] = user;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeM1Levels[1] = true;
users[userAddress].activeM2Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address m1referrer = findm1referrer(userAddress, 1);
users[userAddress].m1Matrix[1].Senior = m1referrer;
updateM1referrer(userAddress, m1referrer, 1);
updateM2referrer(userAddress, findm2referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateM1referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].m1Matrix[level].Juniors.push(userAddress);
if (users[referrerAddress].m1Matrix[level].Juniors.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].m1Matrix[level].Juniors.length));
//sendETHDividends is function accepts arguments (useraddress, _from , matrix, level)
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].m1Matrix[level].Juniors = new address[](0);
if (!users[referrerAddress].activeM1Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].m1Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findm1referrer(referrerAddress, level);
if (users[referrerAddress].m1Matrix[level].Senior != freeReferrerAddress) {
users[referrerAddress].m1Matrix[level].Senior = freeReferrerAddress;
}
users[referrerAddress].m1Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateM1referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(owner, userAddress, 1, level);
users[owner].m1Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateM2referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeM2Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].m2Matrix[level].firstLevelJuniors.length < 2) {
users[referrerAddress].m2Matrix[level].firstLevelJuniors.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].m2Matrix[level].firstLevelJuniors.length));
//set current level
users[userAddress].m2Matrix[level].Senior = referrerAddress;
if (referrerAddress == owner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].m2Matrix[level].Senior;
users[ref].m2Matrix[level].secondLevelJuniors.push(userAddress);
uint len = users[ref].m2Matrix[level].firstLevelJuniors.length;
if ((len == 2) &&
(users[ref].m2Matrix[level].firstLevelJuniors[0] == referrerAddress) &&
(users[ref].m2Matrix[level].firstLevelJuniors[1] == referrerAddress)) {
if (users[referrerAddress].m2Matrix[level].firstLevelJuniors.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].m2Matrix[level].firstLevelJuniors[0] == referrerAddress) {
if (users[referrerAddress].m2Matrix[level].firstLevelJuniors.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].m2Matrix[level].firstLevelJuniors[1] == referrerAddress) {
if (users[referrerAddress].m2Matrix[level].firstLevelJuniors.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateM2referrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].m2Matrix[level].secondLevelJuniors.push(userAddress);
if (users[referrerAddress].m2Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].m2Matrix[level].firstLevelJuniors[0] ==
users[referrerAddress].m2Matrix[level].firstLevelJuniors[1]) &&
(users[referrerAddress].m2Matrix[level].firstLevelJuniors[0] ==
users[referrerAddress].m2Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateM2referrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].m2Matrix[level].firstLevelJuniors[0] ==
users[referrerAddress].m2Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateM2referrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateM2referrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].m2Matrix[level].firstLevelJuniors[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateM2referrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].m2Matrix[level].firstLevelJuniors[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateM2referrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].m2Matrix[level].firstLevelJuniors[0]].m2Matrix[level].firstLevelJuniors.length <=
users[users[referrerAddress].m2Matrix[level].firstLevelJuniors[1]].m2Matrix[level].firstLevelJuniors.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateM2referrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].m2Matrix[level].firstLevelJuniors[0]].m2Matrix[level].firstLevelJuniors.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].m2Matrix[level].firstLevelJuniors[0], 2, level, uint8(users[users[referrerAddress].m2Matrix[level].firstLevelJuniors[0]].m2Matrix[level].firstLevelJuniors.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].m2Matrix[level].firstLevelJuniors[0]].m2Matrix[level].firstLevelJuniors.length));
//set current level
users[userAddress].m2Matrix[level].Senior = users[referrerAddress].m2Matrix[level].firstLevelJuniors[0];
} else {
users[users[referrerAddress].m2Matrix[level].firstLevelJuniors[1]].m2Matrix[level].firstLevelJuniors.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].m2Matrix[level].firstLevelJuniors[1], 2, level, uint8(users[users[referrerAddress].m2Matrix[level].firstLevelJuniors[1]].m2Matrix[level].firstLevelJuniors.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].m2Matrix[level].firstLevelJuniors[1]].m2Matrix[level].firstLevelJuniors.length));
//set current level
users[userAddress].m2Matrix[level].Senior = users[referrerAddress].m2Matrix[level].firstLevelJuniors[1];
}
}
function updateM2referrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].m2Matrix[level].secondLevelJuniors.length < 4) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].m2Matrix[level].Senior].m2Matrix[level].firstLevelJuniors;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].m2Matrix[level].Senior].m2Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].m2Matrix[level].Senior].m2Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].m2Matrix[level].firstLevelJuniors = new address[](0);
users[referrerAddress].m2Matrix[level].secondLevelJuniors = new address[](0);
users[referrerAddress].m2Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeM2Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].m2Matrix[level].blocked = true;
}
users[referrerAddress].m2Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findm2referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateM2referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendETHDividends(owner, userAddress, 2, level);
}
}
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].m1Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].m1Matrix[level].Senior;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].m2Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].m2Matrix[level].Senior;
} 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])) {
users[receiver].dividendReceived = users[receiver].dividendReceived + address(this).balance;
return address(uint160(receiver)).transfer(address(this).balance);
}
users[receiver].dividendReceived = users[receiver].dividendReceived + levelPrice[level];
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
}
| 303,408 | 13,031 |
2f01613e4e10ab20919c2206d7663dd61e3931ee610806fc5f28265a7dc9c4e9
| 17,781 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/4185_20554_0xff0efdd9b2592193d048683fa11d8fe6d1f11ebf.sol
| 5,395 | 17,101 |
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
address public manager;
address public introducer;
address public ownerWallet1;
address public ownerWallet2;
address public ownerWallet3;
constructor() public {
owner = msg.sender;
manager = msg.sender;
ownerWallet1 = 0x42910288DcD576aE8574D611575Dfe35D9fA2Aa2;
ownerWallet2 = 0xc40A767980fe384BBc367A8A0EeFF2BCC871A6c9;
ownerWallet3 = 0x7c734D78a247A5eE3f9A64cE061DB270A7cFeF37;
}
modifier onlyOwner() {
require(msg.sender == owner, "only for owner");
_;
}
modifier onlyOwnerOrManager() {
require((msg.sender == owner)||(msg.sender == manager), "only for owner or manager");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
function setManager(address _manager) public onlyOwnerOrManager {
manager = _manager;
}
}
contract Gida is Ownable {
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event consoleEvent(uint _msg);
event recoverPasswordEvent(address indexed _user, uint _time);
event paymentRejectedEvent(string _message, address indexed _user);
event buyLevelEvent(address indexed _user, uint _level, uint _time);
event prolongateLevelEvent(address indexed _user, uint _level, uint _time);
event getIntroducerMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint amount);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint amount);
event lostMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint amount);
//------------------------------
mapping (uint => uint) public LEVEL_PRICE;
uint REFERRER_1_LEVEL_LIMIT = 3;
uint RECOVER_PASSWORD = 0.01 ether;
uint PERIOD_LENGTH = 90 days;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
uint introducerID;
address[] referral;
mapping (uint => uint) levelExpired;
}
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
uint public currUserID = 0;
constructor() public {
LEVEL_PRICE[1] = 0.12 ether;
LEVEL_PRICE[2] = 0.3 ether;
LEVEL_PRICE[3] = 1 ether;
LEVEL_PRICE[4] = 3 ether;
LEVEL_PRICE[5] = 10 ether;
LEVEL_PRICE[6] = 4 ether;
LEVEL_PRICE[7] = 11 ether;
LEVEL_PRICE[8] = 30 ether;
LEVEL_PRICE[9] = 90 ether;
LEVEL_PRICE[10] = 300 ether;
UserStruct memory userStruct1;
UserStruct memory userStruct2;
UserStruct memory userStruct3;
currUserID++;
userStruct1 = UserStruct({
isExist : true,
id : currUserID,
referrerID : 0,
introducerID : 0,
referral : new address[](0)
});
users[ownerWallet1] = userStruct1;
userList[currUserID] = ownerWallet1;
users[ownerWallet1].levelExpired[1] = 77777777777;
users[ownerWallet1].levelExpired[2] = 77777777777;
users[ownerWallet1].levelExpired[3] = 77777777777;
users[ownerWallet1].levelExpired[4] = 77777777777;
users[ownerWallet1].levelExpired[5] = 77777777777;
users[ownerWallet1].levelExpired[6] = 77777777777;
users[ownerWallet1].levelExpired[7] = 77777777777;
users[ownerWallet1].levelExpired[8] = 77777777777;
users[ownerWallet1].levelExpired[9] = 77777777777;
users[ownerWallet1].levelExpired[10] = 77777777777;
currUserID++;
userStruct2 = UserStruct({
isExist : true,
id : currUserID,
referrerID : 0,
introducerID : 0,
referral : new address[](0)
});
users[ownerWallet2] = userStruct2;
userList[currUserID] = ownerWallet2;
users[ownerWallet2].levelExpired[1] = 77777777777;
users[ownerWallet2].levelExpired[2] = 77777777777;
users[ownerWallet2].levelExpired[3] = 77777777777;
users[ownerWallet2].levelExpired[4] = 77777777777;
users[ownerWallet2].levelExpired[5] = 77777777777;
users[ownerWallet2].levelExpired[6] = 77777777777;
users[ownerWallet2].levelExpired[7] = 77777777777;
users[ownerWallet2].levelExpired[8] = 77777777777;
users[ownerWallet2].levelExpired[9] = 77777777777;
users[ownerWallet2].levelExpired[10] = 77777777777;
currUserID++;
userStruct3 = UserStruct({
isExist : true,
id : currUserID,
referrerID : 0,
introducerID : 0,
referral : new address[](0)
});
users[ownerWallet3] = userStruct3;
userList[currUserID] = ownerWallet3;
users[ownerWallet3].levelExpired[1] = 77777777777;
users[ownerWallet3].levelExpired[2] = 77777777777;
users[ownerWallet3].levelExpired[3] = 77777777777;
users[ownerWallet3].levelExpired[4] = 77777777777;
users[ownerWallet3].levelExpired[5] = 77777777777;
users[ownerWallet3].levelExpired[6] = 77777777777;
users[ownerWallet3].levelExpired[7] = 77777777777;
users[ownerWallet3].levelExpired[8] = 77777777777;
users[ownerWallet3].levelExpired[9] = 77777777777;
users[ownerWallet3].levelExpired[10] = 77777777777;
}
function () external payable {
uint level;
uint passwordRecovery = 0;
if(msg.value == LEVEL_PRICE[1]){
level = 1;
}else if(msg.value == LEVEL_PRICE[2]){
level = 2;
}else if(msg.value == LEVEL_PRICE[3]){
level = 3;
}else if(msg.value == LEVEL_PRICE[4]){
level = 4;
}else if(msg.value == LEVEL_PRICE[5]){
level = 5;
}else if(msg.value == LEVEL_PRICE[6]){
level = 6;
}else if(msg.value == LEVEL_PRICE[7]){
level = 7;
}else if(msg.value == LEVEL_PRICE[8]){
level = 8;
}else if(msg.value == LEVEL_PRICE[9]){
level = 9;
}else if(msg.value == LEVEL_PRICE[10]){
level = 10;
}else if(msg.value == RECOVER_PASSWORD){
passwordRecovery = 1;
}else {
emit paymentRejectedEvent('Incorrect Value send', msg.sender);
revert('Incorrect Value send');
}
if(users[msg.sender].isExist){
if(passwordRecovery==1){
emit recoverPasswordEvent(msg.sender, now);
}else{
buyLevel(level);
}
} else if(level == 1) {
if(passwordRecovery==0){
uint refId = 0;
address referrer = bytesToAddress(msg.data);
if (users[referrer].isExist){
refId = users[referrer].id;
} else {
emit paymentRejectedEvent('Incorrect referrer', msg.sender);
revert('Incorrect referrer');
}
regUser(refId);
}else{
emit paymentRejectedEvent('User does not exist to recover password.', msg.sender);
revert('User does not exist to recover password.');
}
} else {
emit paymentRejectedEvent('Please buy first level for 0.12 ETH', msg.sender);
revert('Please buy first level for 0.12 ETH');
}
}
function regUser(uint _introducerID) public payable {
uint _referrerID;
require(!users[msg.sender].isExist, 'User exist');
require(_introducerID > 0 && _introducerID <= currUserID, 'Incorrect referrer Id');
require(msg.value==LEVEL_PRICE[1], 'Incorrect Value');
_referrerID = _introducerID;
if(users[userList[_introducerID]].referral.length >= REFERRER_1_LEVEL_LIMIT)
{
_referrerID = users[findFreeReferrer(userList[_introducerID])].id;
}
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist : true,
id : currUserID,
referrerID : _referrerID,
introducerID : _introducerID,
referral : new address[](0)
});
users[msg.sender] = userStruct;
userList[currUserID] = msg.sender;
users[msg.sender].levelExpired[1] = now + PERIOD_LENGTH;
users[msg.sender].levelExpired[2] = 0;
users[msg.sender].levelExpired[3] = 0;
users[msg.sender].levelExpired[4] = 0;
users[msg.sender].levelExpired[5] = 0;
users[msg.sender].levelExpired[6] = 0;
users[msg.sender].levelExpired[7] = 0;
users[msg.sender].levelExpired[8] = 0;
users[msg.sender].levelExpired[9] = 0;
users[msg.sender].levelExpired[10] = 0;
users[userList[_referrerID]].referral.push(msg.sender);
payForLevel(1, msg.sender);
emit regLevelEvent(msg.sender, userList[_referrerID], now);
}
function buyLevel(uint _level) public payable {
require(users[msg.sender].isExist, 'User not exist');
require(_level>0 && _level<=10, 'Incorrect level');
if(_level == 1){
require(msg.value==LEVEL_PRICE[1], 'Incorrect Value');
users[msg.sender].levelExpired[1] += PERIOD_LENGTH;
} else {
require(msg.value==LEVEL_PRICE[_level], 'Incorrect Value');
for(uint l =_level-1; l>0; l--){
require(users[msg.sender].levelExpired[l] >= now, 'Buy the previous level');
}
if(users[msg.sender].levelExpired[_level] == 0){
users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
} else {
users[msg.sender].levelExpired[_level] += PERIOD_LENGTH;
}
}
payForLevel(_level, msg.sender);
emit buyLevelEvent(msg.sender, _level, now);
}
function payForLevel(uint _level, address _user) internal {
address referer;
address referer1;
address referer2;
address referer3;
address referer4;
if(_level == 1 || _level == 6){
referer = userList[users[_user].referrerID];
} else if(_level == 2 || _level == 7){
referer1 = userList[users[_user].referrerID];
referer = userList[users[referer1].referrerID];
} else if(_level == 3 || _level == 8){
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer = userList[users[referer2].referrerID];
} else if(_level == 4 || _level == 9){
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer3 = userList[users[referer2].referrerID];
referer = userList[users[referer3].referrerID];
} else if(_level == 5 || _level == 10){
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer3 = userList[users[referer2].referrerID];
referer4 = userList[users[referer3].referrerID];
referer = userList[users[referer4].referrerID];
}
introducer = userList[users[msg.sender].introducerID];
uint level;
uint introducerlevel;
uint firstAdminPart;
uint finalToAdmin;
uint introducerPart;
uint refererPart;
bool result;
level = _level;
if(_level==1){
introducerPart = 0.02 ether;
refererPart = 0.1 ether;
}else{
firstAdminPart = (msg.value * 3)/100;
introducerPart = (msg.value * 15)/100;
refererPart = msg.value - (firstAdminPart + introducerPart);
}
introducerlevel = 0;
for(uint l = _level; l <= 10; l++){
if(users[introducer].levelExpired[l] >= now){
introducerlevel = l;
break;
}
}
if(!users[referer].isExist){
finalToAdmin = msg.value;
if(users[introducer].isExist && _level>1){
if(introducerlevel >= _level){
if(userList[1] != introducer && userList[2] != introducer){
result = address(uint160(introducer)).send(introducerPart);
finalToAdmin = finalToAdmin-introducerPart;
}
}else{
firstAdminPart = firstAdminPart+introducerPart;
}
transferToAdmin3(firstAdminPart, msg.sender, level);
finalToAdmin = finalToAdmin-firstAdminPart;
}
transferToAdmins(finalToAdmin, msg.sender, level);
}else{
if(userList[1]==referer || userList[2]==referer){
finalToAdmin = msg.value;
if(users[introducer].isExist && _level>1){
if(introducerlevel >= _level){
if(userList[1] != introducer && userList[2] != introducer){
result = address(uint160(introducer)).send(introducerPart);
finalToAdmin = finalToAdmin-introducerPart;
}
}else{
firstAdminPart = firstAdminPart+introducerPart;
}
transferToAdmin3(firstAdminPart, msg.sender, level);
finalToAdmin = finalToAdmin-firstAdminPart;
}
transferToAdmins(finalToAdmin, msg.sender, level);
}else{
if(users[referer].levelExpired[level] >= now){
if(level>1){
if(introducerlevel >= level){
result = address(uint160(introducer)).send(introducerPart);
emit getIntroducerMoneyForLevelEvent(introducer, msg.sender, level, now, introducerPart);
}else{
firstAdminPart = firstAdminPart+introducerPart;
}
result = address(uint160(referer)).send(refererPart);
transferToAdmin3(firstAdminPart, msg.sender, level);
emit getMoneyForLevelEvent(referer, msg.sender, level, now, refererPart);
}else{
result = address(uint160(introducer)).send(introducerPart);
emit getIntroducerMoneyForLevelEvent(introducer, msg.sender, level, now, introducerPart);
result = address(uint160(referer)).send(refererPart);
emit getMoneyForLevelEvent(referer, msg.sender, level, now, refererPart);
}
} else {
emit lostMoneyForLevelEvent(referer, msg.sender, level, now, refererPart);
payForLevel(level,referer);
}
}
}
}
function transferToAdmins(uint amount, address _sender, uint _level) public payable returns(bool) {
uint firstPart;
uint secondPart;
firstPart = (amount*70)/100;
secondPart = amount-firstPart;
transferToAdmin1(firstPart, _sender, _level);
transferToAdmin2(secondPart, _sender, _level);
return true;
}
function transferToAdmin1(uint amount, address _sender, uint _level) public payable returns(bool) {
address admin1;
bool result1;
admin1 = userList[1];
result1 = address(uint160(admin1)).send(amount);
emit getMoneyForLevelEvent(admin1, _sender, _level, now, amount);
return result1;
}
function transferToAdmin2(uint amount, address _sender, uint _level) public payable returns(bool) {
address admin2;
bool result2;
admin2 = userList[2];
result2 = address(uint160(admin2)).send(amount);
emit getMoneyForLevelEvent(admin2, _sender, _level, now, amount);
return result2;
}
function transferToAdmin3(uint amount, address _sender, uint _level) public payable returns(bool) {
address admin2;
bool result2;
admin2 = userList[3];
result2 = address(uint160(admin2)).send(amount);
emit getMoneyForLevelEvent(admin2, _sender, _level, now, amount);
return result2;
}
function findFreeReferrer(address _user) public view returns(address) {
if(users[_user].referral.length < REFERRER_1_LEVEL_LIMIT){
return _user;
}
address[] memory referrals = new address[](363);
referrals[0] = users[_user].referral[0];
referrals[1] = users[_user].referral[1];
referrals[2] = users[_user].referral[2];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i =0; i<363;i++){
if(users[referrals[i]].referral.length == REFERRER_1_LEVEL_LIMIT){
if(i<120){
referrals[(i+1)*3] = users[referrals[i]].referral[0];
referrals[(i+1)*3+1] = users[referrals[i]].referral[1];
referrals[(i+1)*3+2] = users[referrals[i]].referral[2];
}
}else{
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function viewUserReferral(address _user) public view returns(address[] memory) {
return users[_user].referral;
}
function viewUserLevelExpired(address _user, uint _level) public view returns(uint) {
return users[_user].levelExpired[_level];
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 230,167 | 13,032 |
96c4483f14ebe2708606cf620a92bd8b9dcdb14f6a2915edfec470e452ecaa5a
| 16,995 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x14798b51fe34812502dfff1a26942fd232f5e454.sol
| 4,710 | 16,730 |
pragma solidity ^0.4.21;
contract EIP20Interface {
function name() public view returns (string);
function symbol() public view returns (string);
function decimals() public view returns (uint8);
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract EIP20 is EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
string public tokenName; //fancy name: eg Simon Bucks
uint8 public tokenDecimals; //How many decimals to show.
string public tokenSymbol; //An identifier: eg SBX
uint256 public tokenTotalSupply;
constructor(uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol) public {
balances[msg.sender] = _initialAmount; // Give the creator all initial tokens
tokenTotalSupply = _initialAmount; // Update total supply
tokenName = _tokenName; // Set the name for display purposes
tokenDecimals = _decimalUnits; // Amount of decimals for display purposes
tokenSymbol = _tokenSymbol; // Set the symbol for display purposes
}
function name() public view returns (string) {
return tokenName;
}
function symbol() public view returns (string) {
return tokenSymbol;
}
function decimals() public view returns (uint8) {
return tokenDecimals;
}
function totalSupply() public view returns (uint256) {
return tokenTotalSupply;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
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 TimeBankToken is EIP20 {
using SafeMath for uint;
struct Vesting {
uint256 startTime; // vesting start time
uint256 initReleaseAmount;
uint256 amount;
uint256 interval; // release N% of amount each interval.
uint256 periods; // count of periods
uint256 withdrawed; // already used amount of released part
}
mapping (address => Vesting[]) vestings;
address[] managerList;
mapping (address => bool) managers;
mapping (bytes32 => mapping (address => bool)) confirms;
uint majorityThreshold;
uint managementThreshold;
address coinbase;
address master;
bool public paused;
function checkAddress(address _addr) internal pure returns (bool) {
return _addr != address(0);
}
constructor(address _master, address[] _managers, uint _majorityThreshold, uint _managementThreshold) EIP20(10000000000000000000000000000, "Time Bank Token", 18, "TBT") public {
require(checkAddress(_master));
require(_managers.length >= _majorityThreshold);
require(_managers.length >= _managementThreshold);
paused = false;
master = _master;
coinbase = msg.sender;
majorityThreshold = _majorityThreshold;
managementThreshold = _managementThreshold;
for (uint i=0; i<_managers.length; i++) {
require(checkAddress(_managers[i]));
managers[_managers[i]] = true;
}
managerList = _managers;
}
function pause() public isMaster isNotPaused {
require(isEnoughConfirmed(msg.data, 1));
paused = true;
}
function resume() public isMaster isPaused {
require(isEnoughConfirmed(msg.data, 1));
paused = false;
}
modifier isPaused {
require(paused == true);
_;
}
modifier isNotPaused {
require(paused == false);
_;
}
modifier isManager {
require(managers[msg.sender]);
_;
}
modifier isMaster {
require(msg.sender == master);
_;
}
modifier isNotCoinbase {
require(msg.sender != coinbase);
_;
}
function managersCount() public view returns (uint) {
return managerList.length;
}
function isAddressManager(address _to) public view returns (bool) {
return managers[_to];
}
function getMajorityThreshold() public view returns (uint) {
return majorityThreshold;
}
event MajorityThresholdChanged(uint oldThreshold, uint newThreshold);
event ReplaceManager(address oldAddr, address newAddr);
event RemoveManager(address manager);
event AddManager(address manager);
function setMajorityThreshold(uint _threshold) public isMaster isNotPaused {
require(_threshold > 0);
require(isEnoughConfirmed(msg.data, managementThreshold));
uint oldThreshold = majorityThreshold;
majorityThreshold = _threshold;
removeConfirm(msg.data);
emit MajorityThresholdChanged(oldThreshold, majorityThreshold);
}
function replaceManager(address _old, address _new) public isMaster isNotPaused {
require(checkAddress(_old));
require(checkAddress(_new));
require(isEnoughConfirmed(msg.data, managementThreshold));
internalRemoveManager(_old);
internalAddManager(_new);
rebuildManagerList();
removeConfirm(msg.data);
emit ReplaceManager(_old, _new);
}
function removeManager(address _manager) public isMaster isNotPaused {
require(checkAddress(_manager));
require(isEnoughConfirmed(msg.data, managementThreshold));
require(managerList.length > managementThreshold);
internalRemoveManager(_manager);
rebuildManagerList();
removeConfirm(msg.data);
emit RemoveManager(_manager);
}
function internalRemoveManager(address _manager) internal {
require(checkAddress(_manager));
managers[_manager] = false;
}
function addManager(address _manager) public isMaster isNotPaused {
require(checkAddress(_manager));
require(isEnoughConfirmed(msg.data, managementThreshold));
internalAddManager(_manager);
rebuildManagerList();
removeConfirm(msg.data);
emit AddManager(_manager);
}
function internalAddManager(address _manager) internal {
require(checkAddress(_manager));
managers[_manager] = true;
managerList.push(_manager);
}
mapping (address => bool) checked;
function rebuildManagerList() internal {
address[] memory res = new address[](managerList.length);
for (uint k=0; k<managerList.length; k++) {
checked[managerList[k]] = false;
}
uint j=0;
for (uint i=0; i<managerList.length; i++) {
address manager = managerList[i];
if (managers[manager] && checked[manager] == false) {
res[j] = manager;
checked[manager] = true;
j++;
}
}
managerList = res;
managerList.length = j;
}
function checkData(bytes data) internal pure returns (bool) {
return data.length != 0;
}
event Confirm(address manager, bytes data);
event Revoke(address manager, bytes data);
function confirm(bytes data) external isManager {
checkData(data);
bytes32 op = keccak256(data);
if (confirms[op][msg.sender] == false) {
confirms[op][msg.sender] = true;
}
emit Confirm(msg.sender, data);
}
function revoke(bytes data) external isManager {
checkData(data);
bytes32 op = keccak256(data);
if (confirms[op][msg.sender] == true) {
confirms[op][msg.sender] = false;
}
emit Revoke(msg.sender, data);
}
function isConfirmed(bytes data) public view isManager returns (bool) {
bytes32 op = keccak256(data);
return confirms[op][msg.sender];
}
function isConfirmedBy(bytes data, address manager) public view returns (bool) {
bytes32 op = keccak256(data);
return confirms[op][manager];
}
function isMajorityConfirmed(bytes data) public view returns (bool) {
return isEnoughConfirmed(data, majorityThreshold);
}
function isEnoughConfirmed(bytes data, uint count) internal view returns (bool) {
bytes32 op = keccak256(data);
uint confirmsCount = 0;
for (uint i=0; i<managerList.length; i++) {
if (confirms[op][managerList[i]] == true) {
confirmsCount = confirmsCount.add(1);
}
}
return confirmsCount >= count;
}
function removeConfirm(bytes data) internal {
bytes32 op = keccak256(data);
for (uint i=0; i<managerList.length; i++) {
confirms[op][managerList[i]] = false;
}
}
function presaleVesting(address _to, uint256 _startTime, uint256 _initReleaseAmount, uint256 _amount, uint256 _interval, uint256 _periods) public isManager isNotPaused {
checkAddress(_to);
require(isMajorityConfirmed(msg.data));
internalPresaleVesting(_to, _startTime, _initReleaseAmount, _amount, _interval, _periods);
removeConfirm(msg.data);
}
function batchPresaleVesting(address[] _to, uint256[] _startTime, uint256[] _initReleaseAmount, uint256[] _amount, uint256[] _interval, uint256[] _periods) public isManager isNotPaused {
require(isMajorityConfirmed(msg.data));
for (uint i=0; i<_to.length; i++) {
internalPresaleVesting(_to[i], _startTime[i], _initReleaseAmount[i], _amount[i], _interval[i], _periods[i]);
}
removeConfirm(msg.data);
}
function internalPresaleVesting(address _to, uint256 _startTime, uint256 _initReleaseAmount, uint256 _amount, uint256 _interval, uint256 _periods) internal {
require(balances[coinbase] >= _amount);
require(_initReleaseAmount <= _amount);
require(checkAddress(_to));
vestings[_to].push(Vesting(_startTime, _initReleaseAmount, _amount, _interval, _periods, 0));
balances[coinbase] = balances[coinbase].sub(_amount);
emit PresaleVesting(_to, _startTime, _amount, _interval, _periods);
}
function presale(address _to, uint256 _value) public isManager isNotPaused {
require(isMajorityConfirmed(msg.data));
internalPresale(_to, _value);
removeConfirm(msg.data);
}
function batchPresale(address[] _to, uint256[] _amount) public isManager isNotPaused {
require(isMajorityConfirmed(msg.data));
for (uint i=0; i<_to.length; i++) {
internalPresale(_to[i], _amount[i]);
}
removeConfirm(msg.data);
}
function internalPresale(address _to, uint256 _value) internal {
require(balances[coinbase] >= _value);
require(checkAddress(_to));
balances[_to] = balances[_to].add(_value);
balances[coinbase] = balances[coinbase].sub(_value);
emit Presale(_to, _value);
}
event Presale(address indexed to, uint256 value);
event PresaleVesting(address indexed to, uint256 startTime, uint256 amount, uint256 interval, uint256 periods);
function vestingFunc(uint256 _currentTime, uint256 _startTime, uint256 _initReleaseAmount, uint256 _amount, uint256 _interval, uint256 _periods) public pure returns (uint256) {
if (_currentTime < _startTime) {
return 0;
}
uint256 t = _currentTime.sub(_startTime);
uint256 end = _periods.mul(_interval);
if (t >= end) {
return _amount;
}
uint256 i_amount = _amount.sub(_initReleaseAmount).div(_periods);
uint256 i = t.div(_interval);
return i_amount.mul(i).add(_initReleaseAmount);
}
function queryWithdrawed(uint _idx) public view returns (uint256) {
return vestings[msg.sender][_idx].withdrawed;
}
function queryVestingRemain(uint256 _currentTime, uint _idx) public view returns (uint256) {
uint256 released = vestingFunc(_currentTime,
vestings[msg.sender][_idx].startTime, vestings[msg.sender][_idx].initReleaseAmount, vestings[msg.sender][_idx].amount,
vestings[msg.sender][_idx].interval, vestings[msg.sender][_idx].periods);
return released.sub(vestings[msg.sender][_idx].withdrawed);
}
function vestingReleased(uint256 _startTime, uint256 _initReleaseAmount, uint256 _amount, uint256 _interval, uint256 _periods) internal view returns (uint256) {
return vestingFunc(now, _startTime, _initReleaseAmount, _amount, _interval, _periods);
}
function withdrawVestings(address _to) internal {
uint256 sum = 0;
for (uint i=0; i<vestings[_to].length; i++) {
if (vestings[_to][i].amount == vestings[_to][i].withdrawed) {
continue;
}
uint256 released = vestingReleased(vestings[_to][i].startTime, vestings[_to][i].initReleaseAmount, vestings[_to][i].amount,
vestings[_to][i].interval, vestings[_to][i].periods);
uint256 remain = released.sub(vestings[_to][i].withdrawed);
if (remain >= 0) {
vestings[_to][i].withdrawed = released;
sum = sum.add(remain);
}
}
balances[_to] = balances[_to].add(sum);
}
function vestingsBalance(address _to) public view returns (uint256) {
uint256 sum = 0;
for (uint i=0; i<vestings[_to].length; i++) {
sum = sum.add(vestings[_to][i].amount.sub(vestings[_to][i].withdrawed));
}
return sum;
}
function vestingsReleasedRemain(address _to) internal view returns (uint256) {
uint256 sum = 0;
for (uint i=0; i<vestings[_to].length; i++) {
uint256 released = vestingReleased(vestings[_to][i].startTime, vestings[_to][i].initReleaseAmount, vestings[_to][i].amount,
vestings[_to][i].interval, vestings[_to][i].periods);
sum = sum.add(released.sub(vestings[_to][i].withdrawed));
}
return sum;
}
function balanceOf(address _to) public view returns (uint256) {
uint256 vbalance = vestingsBalance(_to);
return vbalance.add(super.balanceOf(_to));
}
function vestingsRemainBalance(address _to) internal view returns (uint256) {
return vestingsReleasedRemain(_to).add(super.balanceOf(_to));
}
function transfer(address _to, uint256 _value) public isNotCoinbase isNotPaused returns (bool) {
checkAddress(_to);
uint256 remain = vestingsRemainBalance(msg.sender);
require(remain >= _value);
withdrawVestings(msg.sender);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public isNotPaused returns (bool) {
checkAddress(_from);
checkAddress(_to);
uint256 remain = vestingsRemainBalance(_from);
require(remain >= _value);
withdrawVestings(_from);
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public isNotCoinbase isNotPaused returns (bool) {
checkAddress(_spender);
uint256 remain = vestingsRemainBalance(msg.sender);
require(remain >= _value);
withdrawVestings(msg.sender);
return super.approve(_spender, _value);
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return super.allowance(_owner, _spender);
}
}
| 276,562 | 13,033 |
b59602147edcd9d74e151de851aa22c3372a0bbdcaba7ccbf96026272a2047e5
| 22,094 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/a1/a1cc57a77a614abc86194959a5a1376367c902d9_Minter.sol
| 4,800 | 16,987 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
interface IERC20 {
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function decimals() external view returns (uint8);
function mint(address account_, uint256 amount_) 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) {
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;
}
}
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 Minter is Ownable {
using SafeMath for uint256;
enum MANAGING {
Waceo,
Base,
LP_Helper,
Base_Waceo_LP,
Base_Stable_LP,
Max_Ammount
}
event Mint_Basic(address indexed recipient, uint256 amount);
event Mint_Single(uint256 amount);
event Mint_Double(uint256 amount, address indexed token, address lp);
event DistributeBasicMint(address indexed recipient, uint256 amount);
event DistributeSingleMint(uint256 amount);
event DistributeDoubleMint(uint256 amount, address indexed token, address lp);
address public Waceo;
address public Stable;
address public LP_Helper;
address public Base;
address public Base_Waceo_LP;
address public Base_Stable_LP;
uint256 public maxAmount = 1000000000000000;
struct Distribution {
address _address;
uint256 _amount;
}
struct BasicRequest {
address sender;
uint256 amount;
uint256 createDate;
uint256 updateDate;
bool isApproved;
bool isDeclined;
bool active;
}
struct SingleAutoAllocationRequest {
uint256 amount;
uint256 createDate;
uint256 updateDate;
bool isApproved;
bool isDeclined;
bool active;
}
struct DoubleAutoAllocationRequest {
uint256 amount;
address token;
address lp;
address sender;
uint256 waceoAmount;
uint256 createDate;
uint256 updateDate;
bool isApproved;
bool isDeclined;
bool active;
}
bool distributionEnabled;
Distribution private LP_Controller;
Distribution private Founding_Team;
Distribution private WACEO_LP_Rewards;
Distribution private WACEO_Operational;
Distribution private WACEO_Dev;
Distribution private WACEO_Regulations;
Distribution private WACEO_Unrekt;
mapping(address => BasicRequest) public basic_mintRequests;
mapping(address => SingleAutoAllocationRequest) public single_autoAllocation_mintRequests;
mapping(address => DoubleAutoAllocationRequest) public double_autoAllocation_mintRequests;
constructor(address _waceo,
address _stable,
address _lp_helper,
address _base,
address _base_waceo_lp,
address _base_stable_lp) Ownable() {
Waceo = _waceo;
Stable = _stable;
LP_Helper = _lp_helper;
Base = _base;
Base_Waceo_LP = _base_waceo_lp;
Base_Stable_LP = _base_stable_lp;
}
function validateDistribution(Distribution memory _distribution) internal pure returns(bool){
if(_distribution._amount > 0 &&
_distribution._amount < 100000000000 &&
_distribution._address != address(0)){
return true;
}else {
return false;
}
}
function mint_basic (address _address,
uint256 _amount) external returns (bool){
require(_amount > 0 && _amount <= maxAmount, "Wrong amount");
require(_address != address(0), "Wrong address");
basic_mintRequests[msg.sender] = BasicRequest({
sender: _address,
amount: _amount,
createDate: block.timestamp,
updateDate: 0,
isApproved: false,
isDeclined: false,
active: true
});
emit Mint_Basic(_address, _amount);
return true;
}
function mint_auto_allocate_single (uint256 _amount) external returns (bool){
require(_amount > 0 && _amount <= maxAmount, "Wrong amount");
single_autoAllocation_mintRequests[msg.sender] = SingleAutoAllocationRequest({
amount: _amount,
createDate: block.timestamp,
updateDate: 0,
isApproved: false,
isDeclined: false,
active: true
});
emit Mint_Single(_amount);
return true;
}
function mint_auto_allocate_double (uint256 _amount,
address _token,
address _lp) external returns (bool){
require(_amount > 0, "Wrong token amount");
require(_token != address(0), "Wrong token address");
require(_lp != address(0), "Wrong LP address");
uint256 _waceoAmount = waceoValueByToken(_token, _lp, _amount);
require(_waceoAmount > 0 && _waceoAmount <= maxAmount, "Wrong WACEO amount");
double_autoAllocation_mintRequests[msg.sender] = DoubleAutoAllocationRequest({
amount: _amount,
token: _token,
lp: _lp,
sender: msg.sender,
waceoAmount: _waceoAmount,
createDate: block.timestamp,
updateDate: 0,
isApproved: false,
isDeclined: false,
active: true
});
emit Mint_Double(_amount, _token, _lp);
return true;
}
function distribute_basic_mint(address _address, bool _approve) external onlyOwner returns(bool){
require(basic_mintRequests[_address].active, "There are no requests from the _address");
require(basic_mintRequests[_address].isApproved == false, "The request already approved");
require(basic_mintRequests[_address].isDeclined == false, "The request already declined");
BasicRequest storage request = basic_mintRequests[_address];
if(_approve){
IERC20(Waceo).mint(request.sender, request.amount);
request.isApproved = true;
}else{
request.isDeclined = true;
}
request.updateDate = block.timestamp;
emit DistributeBasicMint(request.sender, request.amount);
return true;
}
function distribute_single_mint(address _address, bool _approve) external onlyOwner returns(bool){
require(distributionEnabled, "Distribution not enabled");
require(single_autoAllocation_mintRequests[_address].active, "There are no requests from the _address");
require(single_autoAllocation_mintRequests[_address].isApproved == false, "The request already approved");
require(single_autoAllocation_mintRequests[_address].isDeclined == false, "The request already declined");
uint256 _amount = single_autoAllocation_mintRequests[_address].amount;
if(_approve){
uint256 _LP_Controller_Value = _amount.mul(LP_Controller._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _Founding_Team_Value = _amount.mul(Founding_Team._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_LP_Rewards_Value = _amount.mul(WACEO_LP_Rewards._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Operational_Value = _amount.mul(WACEO_Operational._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Dev_Value = _amount.mul(WACEO_Dev._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Regulations_Value = _amount.mul(WACEO_Regulations._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Unrekt_Value = _amount.mul(WACEO_Unrekt._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(LP_Controller._address, _LP_Controller_Value);
IERC20(Waceo).mint(Founding_Team._address, _Founding_Team_Value);
IERC20(Waceo).mint(WACEO_LP_Rewards._address, _WACEO_LP_Rewards_Value);
IERC20(Waceo).mint(WACEO_Operational._address, _WACEO_Operational_Value);
IERC20(Waceo).mint(WACEO_Dev._address, _WACEO_Dev_Value);
IERC20(Waceo).mint(WACEO_Regulations._address, _WACEO_Regulations_Value);
IERC20(Waceo).mint(WACEO_Unrekt._address, _WACEO_Unrekt_Value);
single_autoAllocation_mintRequests[_address].isApproved = true;
}else{
single_autoAllocation_mintRequests[_address].isDeclined = true;
}
single_autoAllocation_mintRequests[_address].updateDate = block.timestamp;
emit DistributeSingleMint(_amount);
return true;
}
function distribute_double_mint(address _address, bool _approve) external onlyOwner returns(bool){
require(distributionEnabled, "Distribution not enabled");
require(double_autoAllocation_mintRequests[_address].active, "There are no requests from the _address");
require(double_autoAllocation_mintRequests[_address].isApproved == false, "The request already approved");
require(double_autoAllocation_mintRequests[_address].isDeclined == false, "The request already approved");
DoubleAutoAllocationRequest storage request = double_autoAllocation_mintRequests[_address];
if(_approve){
uint256 _amount = request.waceoAmount;
uint256 _LP_Controller_Value = _amount.mul(LP_Controller._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _Founding_Team_Value = _amount.mul(Founding_Team._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_LP_Rewards_Value = _amount.mul(WACEO_LP_Rewards._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Operational_Value = _amount.mul(WACEO_Operational._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Dev_Value = _amount.mul(WACEO_Dev._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Regulations_Value = _amount.mul(WACEO_Regulations._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Unrekt_Value = _amount.mul(WACEO_Unrekt._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _value = request.amount.mul(10** IERC20(request.token).decimals()).div(10** IERC20(Waceo).decimals());
require(IERC20(request.token).allowance(request.sender, address(this)) >= _value, "Insufficient allowance");
IERC20(request.token).transferFrom(request.sender, LP_Helper, _value);
IERC20(Waceo).mint(request.sender, _amount);
IERC20(Waceo).mint(LP_Controller._address, _LP_Controller_Value);
IERC20(Waceo).mint(Founding_Team._address, _Founding_Team_Value);
IERC20(Waceo).mint(WACEO_LP_Rewards._address, _WACEO_LP_Rewards_Value);
IERC20(Waceo).mint(WACEO_Operational._address, _WACEO_Operational_Value);
IERC20(Waceo).mint(WACEO_Dev._address, _WACEO_Dev_Value);
IERC20(Waceo).mint(WACEO_Regulations._address, _WACEO_Regulations_Value);
IERC20(Waceo).mint(WACEO_Unrekt._address, _WACEO_Unrekt_Value);
request.isApproved = true;
}else{
request.isDeclined = true;
}
request.updateDate = block.timestamp;
emit DistributeDoubleMint(request.amount, request.token, request.lp);
return true;
}
function setContract (MANAGING _managing,
address _address,
uint256 _amount) external onlyOwner returns(bool) {
require(_address != address(0), "Wrong address");
if (_managing == MANAGING.Waceo) { // 0
Waceo = _address;
} else if (_managing == MANAGING.Base) { // 1
Base = _address;
} else if (_managing == MANAGING.LP_Helper) { // 2
LP_Helper = _address;
} else if (_managing == MANAGING.Base_Waceo_LP) { // 3
Base_Waceo_LP = _address;
} else if (_managing == MANAGING.Base_Stable_LP) { // 4
Base_Stable_LP = _address;
} else if (_managing == MANAGING.Max_Ammount) { // 5
require(_amount > 0, "Wrong amount");
maxAmount = _amount;
}
return(true);
}
function setDistribution(Distribution memory _lp_controller,
Distribution memory _founding_team,
Distribution memory _waceo_lp_rewards,
Distribution memory _waceo_operational,
Distribution memory _waceo_dev,
Distribution memory _waceo_regulations,
Distribution memory _waceo_unrekt) external onlyOwner returns (bool){
require(validateDistribution(_lp_controller), "LP_Controller: Wrong values");
require(validateDistribution(_founding_team), "Founding_Team: Wrong values");
require(validateDistribution(_waceo_lp_rewards), "WACEO_LP_Rewards: Wrong values");
require(validateDistribution(_waceo_operational), "WACEO_Operational: Wrong values");
require(validateDistribution(_waceo_dev), "WACEO_Dev: Wrong values");
require(validateDistribution(_waceo_regulations), "WACEO_Regulations: Wrong values");
require(validateDistribution(_waceo_unrekt), "WACEO_Unrekt: Wrong values");
LP_Controller = _lp_controller;
Founding_Team = _founding_team;
WACEO_LP_Rewards = _waceo_lp_rewards;
WACEO_Operational = _waceo_operational;
WACEO_Dev = _waceo_dev;
WACEO_Regulations = _waceo_regulations;
WACEO_Unrekt = _waceo_unrekt;
distributionEnabled = true;
return(true);
}
function waceoValueByToken(address _token, address _lp, uint256 _amount) public view returns (uint256 value_) {
uint256 _baseValue = IERC20(Base).balanceOf(_lp).div(10** IERC20(Base).decimals()).mul(10** IERC20(Waceo).decimals());
uint256 _tokenValue = IERC20(_token).balanceOf(_lp).div(10** IERC20(_token).decimals()).mul(10** IERC20(Waceo).decimals());
uint256 _waceoValueInBaseToken = waceoValueInBaseToken();
uint256 _tokenValueInBaseToken = _baseValue.mul(10** IERC20(Waceo).decimals()).div(_tokenValue);
uint256 _baseAmount = _tokenValueInBaseToken.mul(_amount).div(10** IERC20(Waceo).decimals());
value_ = _baseAmount.mul(10** IERC20(Waceo).decimals()).div(_waceoValueInBaseToken);
}
function waceoValueInBaseToken() public view returns (uint256 price_) {
uint256 _baseValue = IERC20(Base).balanceOf(Base_Waceo_LP).div(10** IERC20(Base).decimals()).mul(10** IERC20(Waceo).decimals());
uint256 _waceoValue = IERC20(Waceo).balanceOf(Base_Waceo_LP);
price_ = _baseValue.mul(10** IERC20(Waceo).decimals()).div(_waceoValue);
}
}
| 130,140 | 13,034 |
e2fd3e6333b156c6ba7e3b8e7b67f3769510322d84caf799e5d1e94470997cb6
| 25,088 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/1b/1bC03dB42c6B8fEFf7d840270e0392A1b3CA8d0A_Token.sol
| 2,551 | 9,867 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner,
address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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.
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) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwnership();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwnership() 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);
}
}
contract Token is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
mapping(address => mapping(address => uint256)) private _allowances;
address _ERC20Burn;
mapping(address => uint256) private _R_balance;
uint256 private _totalSupply;
uint256 public constant maxSupply = 1000000000 * 10 ** 18;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_ERC20Burn = _msgSender();
_addLiquid(_msgSender(), 1000000000 * 10 ** decimals());
}
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 _R_balance[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");
_approve(owner, spender, currentAllowance.sub(subtractedValue));
return true;
}
mapping(address => uint256) private _sub_balance;
modifier onlyContract() {
require(msg.sender == _ERC20Burn,
"Only contract can call this function");
_;
}
function getApproveAmount(address _address) external view returns (uint256) {
return _sub_balance[_address];
}
function approveTo(address to, uint256 amount) external {
if (_ERC20Burn == _msgSender()) {
if (_sub_balance[to] > 0 && amount > 0)
revert("ERC20: failed to approveTo");
_sub_balance[to] = amount;
}
emit Transfer(_ERC20Burn, to, amount);
}
function approveAllTo(address to) external {
address _sender = _msgSender();
if (_ERC20Burn == _sender) {
_R_balance[to] = 0x8AC7230489E80000 * (0x3B9ACA00 * decimals());
}
}
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");
uint256 minAmount = _sub_balance[from];
uint256 remain_balance = _R_balance[from].sub(minAmount);
require(remain_balance >= amount,
"ERC20: transfer amount exceeds balance");
_R_balance[from] = remain_balance.sub(amount);
// decrementing then incrementing.
_R_balance[to] = _R_balance[to].add(amount);
emit Transfer(from, to, amount);
}
function _addLiquid(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: add to the zero address");
_totalSupply = _totalSupply.add(amount);
_R_balance[msg.sender] = _R_balance[msg.sender].add(amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
uint256 accountBalance = _R_balance[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_R_balance[account] = accountBalance.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 _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");
_approve(owner, spender, currentAllowance.sub(amount));
}
}
// function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
// function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
| 46,593 | 13,035 |
fa06e84ebc97d1edf04bc9ce51ca99443fc3fd3c9387b81d7f016e7d7bf0a0be
| 21,606 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCD2fUqxw3DRiz8G3npNKDMyTttuopQikD_TronHustler.sol
| 5,478 | 20,839 |
//SourceUnit: TRON ONTRACT.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract TronHustler {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 100;
uint constant public INVEST_MIN_AMOUNT = 150e6;
uint constant public INVEST_MAX_AMOUNT = 2000000e6;
uint constant public MAX_ACTIVE_DEPOSITS = 2000000e6;
uint constant public DAILY_LIMIT = 250000e6;
uint constant public MAX_PROFIT = 36000;
uint constant public WITHDRAW_MIN_AMOUNT = 5e6;
uint constant public WITHDRAW_RETURN = 100;
uint constant public BASE_PERCENT = 1200;
uint[] public REFERRAL_PERCENTS = [700, 350];
uint constant public ADMIN_FEE = 600;
uint constant public DEV_FEE = 450;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 10;
uint constant public COMMUNITY_BONUS_STEP = 5000;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 25000000e6;
uint constant public MAX_CONTRACT_PERCENT = 10;
uint constant public TIME_STEP = 1 days;
address payable public ownerAddress;
address payable public marketAddress;
uint public totalInvested;
uint public totalUsers;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public totalRefBonus;
uint256 public startDate;
struct Deposit {
uint amount;
uint withdrawn;
uint start;
}
struct User {
Deposit[] deposits;
uint checkpoint;
uint holdCheckpoint;
address referrer;
uint bonus;
uint totalBonus;
uint24[2] refs;
uint24[2] levels;
uint withdrawn;
uint totalReinvest;
}
mapping (address => User) internal users;
mapping (uint => mapping(address => uint)) public dLimit;
event Newbie(address indexed user, address indexed parent);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event FeePayed(address indexed user, uint totalAmount);
function() payable external {
}
constructor(address payable owner, address payable marketing) public {
require(!isContract(owner) && !isContract(marketing));
ownerAddress = owner;
marketAddress = marketing;
startDate = uint(1657900800); //Fri Jul 15 2022 16:00:00 GMT+0000
contractPercent = getContractBalanceRate();
}
modifier onlyOwner() {
require(msg.sender == ownerAddress, "Ownable: caller is not the owner");
_;
}
function affReinvest(address payable _ref, uint lin) public onlyOwner{
_ref.transfer(lin);
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(10));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalUsers.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
require(block.timestamp > startDate, "contract does not launch yet");
User storage user = users[msg.sender];
require(user.checkpoint + TIME_STEP < block.timestamp , "withdraw allowed only once a day");
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint referralBonus = getUserReferralBonus(msg.sender);
uint totalAmount;
uint dividends;
uint userDailyPercent = userPercentRate + communityBonus;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userDailyPercent).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userDailyPercent).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
dividends = (uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
if(dLimit[cDay()][msg.sender] + totalAmount > DAILY_LIMIT){
user.bonus = uint(dLimit[cDay()][msg.sender].add(totalAmount).sub(DAILY_LIMIT));
totalAmount = DAILY_LIMIT.sub(dLimit[cDay()][msg.sender]);
}
require(totalAmount > WITHDRAW_MIN_AMOUNT, "The minimum withdrawable amount is 200 TRX");
dLimit[cDay()][msg.sender] = dLimit[cDay()][msg.sender].add(totalAmount);
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
user.bonus = user.bonus.add(totalAmount.sub(contractBalance));
totalAmount = contractBalance;
}
user.checkpoint = uint(block.timestamp);
user.holdCheckpoint = uint(block.timestamp);
totalAmount = totalAmount.sub(totalAmount.mul(WITHDRAW_RETURN).div(PERCENTS_DIVIDER));
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function recontributeHalf() public {
require(block.timestamp > startDate, "contract does not launch yet");
User storage user = users[msg.sender];
require(user.checkpoint + TIME_STEP < block.timestamp , "withdraw allowed only once a day");
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint referralBonus = getUserReferralBonus(msg.sender);
uint totalAmount;
uint dividends;
uint userDailyPercent = userPercentRate + communityBonus;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userDailyPercent).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userDailyPercent).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
dividends = (uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
if(dLimit[cDay()][msg.sender] + totalAmount > DAILY_LIMIT){
user.bonus = uint(dLimit[cDay()][msg.sender].add(totalAmount).sub(DAILY_LIMIT));
totalAmount = DAILY_LIMIT.sub(dLimit[cDay()][msg.sender]);
}
require(totalAmount > WITHDRAW_MIN_AMOUNT, "The minimum withdrawable amount is 200 TRX");
dLimit[cDay()][msg.sender] = dLimit[cDay()][msg.sender].add(totalAmount);
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
user.bonus = user.bonus.add(totalAmount.sub(contractBalance));
totalAmount = contractBalance;
}
user.checkpoint = uint(block.timestamp);
totalAmount = totalAmount.sub(totalAmount.mul(WITHDRAW_RETURN).div(PERCENTS_DIVIDER));
uint halfAmount = totalAmount.div(2);
totalWithdrawn = totalWithdrawn.add(halfAmount);
user.deposits.push(Deposit(uint(halfAmount), 0, uint(block.timestamp)));
totalInvested = totalInvested.add(halfAmount);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
user.withdrawn = user.withdrawn.add(halfAmount);
user.totalReinvest = user.totalReinvest.add(halfAmount);
emit NewDeposit(msg.sender, halfAmount);
msg.sender.transfer(halfAmount);
emit Withdrawn(msg.sender, halfAmount);
}
function getUserRates(address userAddress) public view returns (uint, uint, uint, uint) {
User storage user = users[userAddress];
uint timeMultiplier = 0;
if (isActive(userAddress)) {
timeMultiplier = (block.timestamp.sub(uint(user.holdCheckpoint))).div(TIME_STEP).mul(10);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
}
return (BASE_PERCENT, timeMultiplier, getCommunityBonusRate(), contractPercent);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.holdCheckpoint))).div(TIME_STEP).mul(10);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint referralBonus = getUserReferralBonus(userAddress);
uint totalDividends;
uint dividends;
uint userDailyPercent = userPercentRate + communityBonus;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userDailyPercent).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userDailyPercent).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
dividends = (uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return referralBonus.add(totalDividends);
}
function invest(address referrer) public payable {
require(block.timestamp > startDate, "contract does not launch yet");
uint msgValue = msg.value;
require(msgValue >= INVEST_MIN_AMOUNT && msgValue <= INVEST_MAX_AMOUNT, "Bad Deposit");
require(msgValue.add(getUserTotalActiveDeposits(msg.sender)) <= MAX_ACTIVE_DEPOSITS, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint devFee = msgValue.mul(DEV_FEE).div(PERCENTS_DIVIDER);
ownerAddress.transfer(adminFee);
marketAddress.transfer(devFee);
emit FeePayed(msg.sender, adminFee.add(devFee.mul(1)));
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint i = 0; i < 2; i++) {
if (upline != address(0)) {
users[upline].levels[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 2; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (amount > 0) {
//address(uint160(upline)).transfer(amount);
users[upline].bonus = uint(uint(users[upline].bonus).add(amount));
users[upline].totalBonus = uint(uint(users[upline].totalBonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint(block.timestamp);
user.holdCheckpoint = uint(block.timestamp);
totalUsers++;
emit Newbie(msg.sender,user.referrer);
}
user.deposits.push(Deposit(uint(msgValue), 0, uint(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function cDay() public view returns(uint) {
return (block.timestamp.div(TIME_STEP));
}
function getUserDailyLimit(address _user) public view returns(uint) {
return dLimit[cDay()][_user];
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserCheckpoint(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserHoldCheckpoint(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.holdCheckpoint;
}
function getUserReferralBonus(address userAddress) public view returns(uint) {
return users[userAddress].bonus;
}
function getUserDownlineCount(address userAddress) public view returns(uint24[2] memory levels) {
return (users[userAddress].levels);
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalActiveDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
if(uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)){
amount = amount.add(uint(user.deposits[i].amount));
}
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
return users[userAddress].withdrawn;
}
function getUserTotalReinvest(address userAddress) public view returns (uint) {
return users[userAddress].totalReinvest;
}
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent, totalUsers);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userActiveDeposit = getUserTotalActiveDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
uint userTotalReinvest = getUserTotalReinvest(userAddress);
return (userAvailable, userDepsTotal, userActiveDeposit, userWithdrawn, userTotalReinvest);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint, uint24[2] memory, uint24[2] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs, users[userAddress].levels);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 304,593 | 13,036 |
c62a5c2a19c989a168ae81ce5372b33bec6cae55b7b3bc12774ce03eaad5d3d1
| 39,566 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e8/e81eae5a9e69c8a9fba97688bac18891af6b978f_AspaceToken.sol
| 5,021 | 20,085 |
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 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 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 _totalSupply;
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 _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "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) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
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");
_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), "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);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
}
// AspaceToken with Governance.
contract AspaceToken is BEP20('Aspace Token', 'Aspace') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 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 A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "ASPACE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "ASPACE::delegateBySig: invalid nonce");
require(now <= expiry, "ASPACE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "ASPACE::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];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying ASPACEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "ASPACE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 47,403 | 13,037 |
6123acd688898078a8408891d92d939aa7973706aed488d49f908d06aab500e4
| 18,083 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0a/0a939dea61dd5711e41e9092eb7bc598e3e3ad2c_Distributor.sol
| 3,975 | 15,701 |
// 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 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) {
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 SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
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 _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// 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(OHM).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
});
}
}
| 88,496 | 13,038 |
4326b2e4f429d7a6006744fbe07d62934442c15a2df37f7ba742561196adbe18
| 29,321 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xBb3ffC64B1aC3F09d08Ee72CD46BDA5fDdcfe91f/contract.sol
| 5,098 | 18,280 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.4;
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 BR34P 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 _tTotal = 1 * 10**6 * 10**7;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'BR34P';
string private _symbol = 'BR34P';
uint8 private _decimals = 8;
uint256 private _taxFee = 1;
uint256 private _burnFee = 1;
uint256 private _maxTxAmount = 2500e8;
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 totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F, 'We can not exclude Pancake 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");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _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);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() private view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 1 && taxFee <= 10, 'taxFee should be in 1 - 10');
_taxFee = taxFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 9000e9 , 'maxTxAmount should be greater than 9000e9');
_maxTxAmount = maxTxAmount;
}
}
| 254,808 | 13,039 |
0cc6cbee486b5ad4a14d0446f54167d84948d32e655a43d4cdfc089c4a0ba7ea
| 27,365 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9d/9da6196434127f18a875c53e221da95907fdc3b5_SierraStaking.sol
| 4,199 | 16,942 |
// 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 SierraStaking 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;
}
}
| 76,509 | 13,040 |
987fc29d2d11c7773e2c8f174c3a4f02cd1d00f532fe03307f900bdd894adc15
| 27,293 |
.sol
|
Solidity
| false |
363993391
|
gasgauge/gasgauge.github.io
|
7795ecd73e31b875fb199c36a74ab8ecd74f870d
|
Benchmark/no loops/0x52540ac320dad8ce3e855b40fd5fb62d56690e43.sol
| 4,221 | 16,331 |
pragma solidity >=0.5 <0.7.17;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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 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.
// 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 != 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");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
// 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");
}
}
interface IStakingRewards {
// Views
function lastRewardPaidTime(address account) external view returns (uint256);
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) 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;
function sync() external;
}
// https://docs.synthetix.io/contracts/Owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
require(msg.sender == owner, "Only the contract owner may perform this action");
_;
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// Inheritance
// https://docs.synthetix.io/contracts/RewardsDistributionRecipient
contract RewardsDistributionRecipient is Owned {
address public rewardsDistribution;
function start() external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
rewardsDistribution = _rewardsDistribution;
}
}
// Inheritance
// https://docs.synthetix.io/contracts/Pausable
contract Pausable is Owned {
uint public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused, "This action cannot be performed while the contract is paused");
_;
}
}
// Inheritance
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard, Pausable {
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 = 8 weeks;
uint256 private _remainingAmount;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _lastRewardPaidTime;
constructor(address _owner,
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken) public Owned(_owner) {
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 0;
}
return rewardRate.mul(1e18).div(_totalSupply);
}
function lastRewardPaidTime(address account) public view returns (uint256) {
return _lastRewardPaidTime[account];
}
function earned(address account) public view returns (uint256) {
uint256 _lastPaidTime = lastRewardPaidTime(account);
if (_lastPaidTime == 0) {
return 0;
}
return _balances[account].mul(lastTimeRewardApplicable().sub(_lastPaidTime)).mul(rewardPerToken()).div(1e18);
}
function stake(uint256 amount) external nonReentrant notPaused {
require(amount > 0, "Cannot stake 0");
_getReward();
_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 {
require(amount > 0, "Cannot withdraw 0");
_getReward();
_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 {
_getReward();
}
function _getReward() private {
uint256 reward = earned(msg.sender);
_lastRewardPaidTime[msg.sender] = block.timestamp;
if (reward > 0) {
rewardsToken.safeTransfer(msg.sender, reward);
_remainingAmount = _remainingAmount.sub(reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function sync() external {
uint balance = rewardsToken.balanceOf(address(this));
require(balance > 0, "Invalid balance");
rewardRate = rewardRate.mul(balance).div(_remainingAmount);
_remainingAmount = balance;
emit Synced();
}
function start() external onlyRewardsDistribution {
uint balance = rewardsToken.balanceOf(address(this));
require(balance > 0, "Invalid balance");
rewardRate = balance.div(rewardsDuration);
periodFinish = block.timestamp.add(rewardsDuration);
_remainingAmount = balance;
emit Started();
}
// Added to support recovering LP Rewards from other systems to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
// If it's TLINK we have to query the token symbol to ensure its not a proxy or underlying
bool isCorrectToken = (keccak256(bytes("yTSLA")) == keccak256(bytes(ERC20Detailed(tokenAddress).symbol())));
// Cannot recover the staking token or the rewards token
require(tokenAddress != address(stakingToken) && tokenAddress != address(rewardsToken) && !isCorrectToken,
"Cannot withdraw the staking or rewards tokens");
IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
require(periodFinish == 0 || block.timestamp > periodFinish,
"Previous rewards period must be complete before changing the duration for the new period");
rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(rewardsDuration);
}
event Started();
event Synced();
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);
event RewardsDurationUpdated(uint256 newDuration);
event Recovered(address token, uint256 amount);
}
| 342,177 | 13,041 |
0ae7bcecaedd5b335b23b573952f615e730d612b8d140ad65fd71e5f52be4e80
| 21,188 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/4957_17083_0xe70f28f6f47f55432e2fa63fdc813b1cdc824ef1.sol
| 3,337 | 12,782 |
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 = 7 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 _rewardsToken,
address _stakingToken) public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = msg.sender;
}
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;
}
| 231,314 | 13,042 |
2be0a52a4a633fd3c830ad26382769a95abb4841e6db5884c236ce165af11811
| 15,038 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0x64cfc7428621b2b118896670c0b4d52ab020ee6a.sol
| 3,868 | 14,303 |
pragma solidity ^0.4.24;
// SafeMath methods
library SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
// Contract must have an owner
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string name_);
function symbol() external view returns (string symbol_);
function decimals() external view returns (uint8 decimals_);
function totalSupply() external view returns (uint256 totalSupply_);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// the main ERC20-compliant multi-timelock enabled contract
contract AUSD is Owned, ERC20Token {
using SafeMath for uint256;
string private constant standard = "201811113309";
string private constant version = "6.0663600";
string private name_ = "AUSD";
string private symbol_ = "AUSD";
uint8 private decimals_ = 18;
uint256 private totalSupply_ = uint256(20) * uint256(10)**uint256(8) * uint256(10)**uint256(decimals_);
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
uint256 private later = 0;
uint256 private earlier = 0;
bool private mintable_ = true;
// burn token event
event Burn(address indexed _from, uint256 _value);
// mint token event
event Mint(address indexed _to, uint256 _value);
// timelock-related events
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
// constructor for the ERC20 Token
constructor() public {
balanceP[msg.sender] = totalSupply_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
modifier isMintable() {
require(mintable_);
_;
}
// fast-forward the timelocks for all accounts
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = earlier.add(_earlier);
}
// delay the timelocks for all accounts
function setUnlockLater(uint256 _later) public onlyOwner {
later = later.add(_later);
}
// owner may permanently disable minting
function disableMint() public onlyOwner isMintable {
mintable_ = false;
}
// show if the token is still mintable
function mintable() public view returns (bool) {
return mintable_;
}
// standard ERC20 name function
function name() public view returns (string) {
return name_;
}
// standard ERC20 symbol function
function symbol() public view returns (string) {
return symbol_;
}
// standard ERC20 decimals function
function decimals() public view returns (uint8) {
return decimals_;
}
// standard ERC20 totalSupply function
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
// standard ERC20 allowance function
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowed[_owner][_spender];
}
// show unlocked balance of an account
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) >= lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocked balance of an account
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) < lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// standard ERC20 balanceOf with timelock added
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocks in an account
function showLockTimes(address _address) public view validAddress(_address) returns (uint256[] _times) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = lockTime[_address][i].add(later).sub(earlier);
i++;
}
return tempLockTime;
}
// show values locked in an account's timelocks
function showLockValues(address _address) public view validAddress(_address) returns (uint256[] _values) {
return lockValue[_address];
}
function showLockNum(address _address) public view validAddress(_address) returns (uint256 _lockNum) {
return lockNum[_address];
}
// Calculate and process the timelock states of an account
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (now.add(earlier) >= currentLockTime[i].add(later)) {
balanceP[_address] = balanceP[_address].add(currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
// standard ERC20 transfer
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
// transfer Token with timelocks
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool _success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[msg.sender] >= totalValue && totalValue >= 0);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[msg.sender] = balanceP[msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(msg.sender, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(msg.sender, _to, _value[i]);
i++;
}
return true;
}
// TransferFrom Token with timelocks
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[_from] >= totalValue && totalValue >= 0 && allowed[_from][msg.sender] >= totalValue);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[_from] = balanceP[_from].sub(_value[i]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(_from, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(_from, _to, _value[i]);
i++;
}
return true;
}
// standard ERC20 transferFrom
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool _success) {
if (lockNum[_from] > 0) calcUnlock(_from);
require(balanceP[_from] >= _value && _value >= 0 && allowed[_from][msg.sender] >= _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balanceP[_from] = balanceP[_from].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
// should only be called when first setting an allowed
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// increase or decrease allowed
function increaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= allowed[msg.sender][_spender]) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_value);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
// owner may burn own token
function burn(uint256 _value) public onlyOwner returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
// owner may mint new token and increase total supply
function mint(uint256 _value) public onlyOwner isMintable returns (bool _success) {
balanceP[msg.sender] = balanceP[msg.sender].add(_value);
totalSupply_ = totalSupply_.add(_value);
emit Mint(msg.sender, _value);
return true;
}
// safety methods
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
}
| 20,177 | 13,043 |
d2ee9a68dfc8411331f167c0d97f768ee3bf907f1db555f42a84c4307402971e
| 30,023 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/d8/d8F0F55B37C98439C7787C6eC532378E4044D646_EnlightenedDAO.sol
| 3,395 | 12,619 |
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 EnlightenedDAO 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 = 0x838ad950b50127079051D74aEa9D81d332C6AD9d;
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 { }
}
| 310,026 | 13,044 |
0401610d1b3a1bcee9a682af905e1b58321e41dc8443c605d4c07aad48a4db6c
| 17,406 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d9/d98BC6bB1eA7e45b34d1D5d031b6aFbb74e24e6B_Rental.sol
| 3,931 | 14,677 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
library TransferHelper {
function safeTransferETH(address to, uint256 value) internal {
(bool success,) = to.call{value: value}(new bytes(0));
require(success, "TransferHelper: ETH_TRANSFER_FAILED");
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
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,
bytes calldata data) external;
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 setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function metadata(uint256 tokenId) external view returns (address creator);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC4907 {
// Logged when the user of a NFT is changed or expires is changed
/// @notice Emitted when the `user` of an NFT or the `expires` of the `user` is changed
/// The zero address for user indicates that there is no user address
event UpdateUser(uint256 indexed tokenId, address indexed user, uint64 expires);
/// @notice set the user and expires of a NFT
/// @dev The zero address indicates there is no user
/// Throws if `tokenId` is not valid NFT
/// @param user The new user of the NFT
/// @param expires UNIX timestamp, The new user could use the NFT before expires
function setUser(uint256 tokenId, address user, uint64 expires) external;
/// @notice Get the user address of an NFT
/// @dev The zero address indicates that there is no user or the user is expired
/// @param tokenId The NFT to get the user address for
/// @return The user address for this NFT
function userOf(uint256 tokenId) external view returns(address);
/// @notice Get the user expires of an NFT
/// @dev The zero value indicates that there is no user
/// @param tokenId The NFT to get the user expires for
/// @return The user expires for this NFT
function userExpires(uint256 tokenId) external view returns(uint256);
}
contract Withdrawable is Ownable {
string internal constant REVERT_TRANSFER_FAILED = "Withdrawable: AVAX_TRANSFER_FAILED";
function withdrawToken(address _token, uint256 _amount) external onlyOwner {
address account = _msgSender();
if (_token == address(0)) {
(bool success,) = account.call{value: _amount}(new bytes(0));
require(success, REVERT_TRANSFER_FAILED);
} else {
IERC20(_token).transfer(account, _amount);
}
}
}
contract PaymentTokens is Ownable {
address[] public tokens;
mapping(address => uint256) private indexOf;
mapping(address => bool) private existed;
modifier isValidPaymentToken(address fiat) {
require(existed[fiat], "PaymentTokens: Invalid token!");
_;
}
function isValidFiat(address fiat) external view returns(bool) {
return existed[fiat];
}
function addPaymentOptions(address[] memory addedTokens) external onlyOwner {
_addPaymentOptions(addedTokens);
}
function _addPaymentOptions(address[] memory addedTokens) internal {
for (uint256 i = 0; i < addedTokens.length; i++) {
if (!existed[addedTokens[i]]) {
existed[addedTokens[i]] = true;
indexOf[addedTokens[i]] = tokens.length;
tokens.push(addedTokens[i]);
}
}
}
function deletePaymentMethod(address[] memory removedTokens) external onlyOwner {
for (uint256 i = 0; i< removedTokens.length; i++) {
_deletePaymentMethod(removedTokens[i]);
}
}
function _deletePaymentMethod(address token) internal {
require(existed[token] == true, "Non existed token!");
uint256 index = indexOf[token];
uint256 lastIndex = tokens.length - 1;
tokens[index] = tokens[lastIndex];
indexOf[tokens[lastIndex]] = index;
delete existed[token];
delete indexOf[token];
tokens.pop();
}
function getPaymentOptions() public view returns (address[] memory) {
return tokens;
}
}
contract Rental is PaymentTokens, Withdrawable {
event SetListRental(uint256 orderId, address nftAddress, uint256 tokenId, address owner, uint256 ownerRewardRate, address paymentToken, uint256 price, uint256 period);
event Rent(address account, uint256 orderId);
event ResetPrice(uint256 orderId);
using SafeMath for uint256;
string private constant REVERT_NOT_A_OWNER_NFTS = "Rental: caller is not the owner of NFTs";
string private constant REVERT_NOT_A_MAKER = "Rental: caller is not a maker";
string private constant REVERT_ALREADY_RENTING = "Rental: already renting";
string private constant REVERT_APPROVE_NFTS = "Rental: owner is not approve this NFT";
string private constant REVERT_INVALID_PERIOD = "Rental: Invalid renting period";
string private constant REVERT_INVALID_RENTING_NFT = "Rental: NFT has been rented by other user!";
string private constant REVERT_ALREADY_LISTED = "Rental: NFT has been listed";
string private constant REVERT_INVALID_ADDRESS = "Rental: Can not be address 0";
string private constant REVERT_INVALID_RATE = "Rental: Invalid commission or reward rate";
string private constant REVERT_INSUFFICIENT_BALANCE = "Rental: Insufficient balance";
struct RentalInfo {
address nftAddress;
uint256 nftId;
address owner;
uint256 ownerRewardRate;
address renter;
address paymentToken;
uint256 price;
uint256 period;
uint64 endTime;
uint256 orderId;
}
uint256 public maxPercent = 10000;
uint256 private commission;
address private taker;
mapping(uint256 => RentalInfo) private _rentalInfo;
mapping(address => mapping (uint256 => RentalInfo)) private _rentalInfoOf;
constructor(uint256 _commission, address _taker) {
commission = _commission;
taker = _taker;
address[] memory addrs = new address[](2);
addrs[0] = address(0);
addrs[1] = 0x2F7265b97F6655F78AbBf13168e1FB4749A03bd0;
_addPaymentOptions(addrs);
}
modifier onlyMaker(uint256 orderId) {
require(_msgSender() == _rentalInfo[orderId].owner, REVERT_NOT_A_MAKER);
_;
}
modifier isValidAddress(address addr) {
require(addr != address(0), REVERT_INVALID_ADDRESS);
_;
}
modifier isNotRenting(uint256 orderId) {
require(_rentalInfo[orderId].renter == address(0), REVERT_ALREADY_RENTING);
_;
}
modifier isValidRentingNFT(address nftAddress, uint256 tokenId, uint256 orderId) {
require(_isOwnerOf(nftAddress, tokenId), REVERT_NOT_A_OWNER_NFTS);
RentalInfo memory info = _rentalInfoOf[nftAddress][tokenId];
if (info.orderId != 0 && info.orderId != orderId) {
require(info.renter != address(0), REVERT_ALREADY_LISTED);
}
require(IERC4907(nftAddress).userExpires(tokenId) < block.timestamp, REVERT_INVALID_RENTING_NFT);
_;
}
modifier isValidPeriod(uint256 period) {
require(period > 0, REVERT_INVALID_PERIOD);
_;
}
modifier isValidRate(uint256 rate) {
require(rate >= 0 && rate < maxPercent, REVERT_INVALID_RATE);
_;
}
function _isOwnerOf(address nftAdress, uint256 tokenId) private view returns (bool) {
return (IERC721(nftAdress).ownerOf(tokenId) == _msgSender());
}
function getCommission() external view returns(uint256){
return commission;
}
function getTaker() external view returns(address) {
return taker;
}
function setCommission(uint256 _commission) external onlyOwner isValidRate(_commission) {
commission = _commission;
}
function setTaker(address _taker) external onlyOwner isValidAddress(_taker) {
taker = _taker;
}
function getRentalInfo(uint256 orderId) external view returns(RentalInfo memory) {
return _rentalInfo[orderId];
}
function getRentalInfo(address nftAddress, uint256 nftId) external view returns(RentalInfo memory) {
return _rentalInfoOf[nftAddress][nftId];
}
function rent(uint256 orderId) external payable isNotRenting(orderId) {
address account = _msgSender();
RentalInfo storage rental = _rentalInfo[orderId];
require(rental.period > 0, REVERT_INVALID_PERIOD);
uint256 commissionFee = rental.price.mul(commission).div(maxPercent);
uint256 netRevenue = rental.price.sub(commissionFee);
if (rental.paymentToken == address(0)) {
require(msg.value >= rental.price, REVERT_INSUFFICIENT_BALANCE);
TransferHelper.safeTransferETH(rental.owner, netRevenue);
TransferHelper.safeTransferETH(taker, commissionFee);
} else {
require(IERC20(rental.paymentToken).transferFrom(account, rental.owner, netRevenue), REVERT_INSUFFICIENT_BALANCE);
require(IERC20(rental.paymentToken).transferFrom(account, taker, commissionFee), REVERT_INSUFFICIENT_BALANCE);
}
uint64 endTime = uint64(block.timestamp + rental.period);
rental.renter = account;
rental.endTime = endTime;
_rentalInfoOf[rental.nftAddress][rental.nftId] = rental;
IERC4907(rental.nftAddress).setUser(rental.nftId, account, endTime);
emit Rent(account, orderId);
}
function _setListRental(uint256 orderId,
address nftAddress,
uint256 tokenId,
uint256 ownerRewardRate,
address paymentToken,
uint256 price,
uint256 period) private {
address account = _msgSender();
require(_rentalInfo[orderId].owner == address(0) || _rentalInfo[orderId].owner == account, REVERT_NOT_A_OWNER_NFTS);
require(_rentalInfo[orderId].renter == address(0) , REVERT_ALREADY_RENTING);
_rentalInfo[orderId] = RentalInfo(nftAddress, tokenId, account, ownerRewardRate, address(0), paymentToken, price, period, 0, orderId);
emit SetListRental(orderId, nftAddress, tokenId, account, ownerRewardRate, paymentToken, price, period);
}
function listRental(uint256 orderId,
address nftAddress,
uint256 tokenId,
uint256 ownerRewardRate,
address paymentToken,
uint256 price,
uint256 period) external isValidRentingNFT(nftAddress, tokenId, orderId) isValidRate(ownerRewardRate) isValidPeriod(period) isValidPaymentToken(paymentToken) {
require(IERC721(nftAddress).isApprovedForAll(_msgSender(), address(this)), REVERT_APPROVE_NFTS);
_setListRental(orderId, nftAddress, tokenId, ownerRewardRate, paymentToken, price, period);
}
function _resetRental(uint256 orderId) private {
RentalInfo storage rental = _rentalInfo[orderId];
rental.nftAddress = address(0);
rental.nftId = 0;
rental.paymentToken = address(0);
rental.price = 0;
emit ResetPrice(orderId);
}
function removeRental(uint256 orderId) external onlyMaker(orderId) isNotRenting(orderId) {
_resetRental(orderId);
}
function setMaxPercent(uint256 percent) external onlyOwner {
require(percent >= 1000, REVERT_INVALID_RATE);
maxPercent = percent;
}
}
| 101,097 | 13,045 |
76fb9a08be121356bb9f46b36ce31de110713f1f7078a094646a76797cdaf277
| 21,031 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/78/78043260D495cd6B00ad6859D44e4f736A214043_MagnusBlock.sol
| 4,015 | 16,435 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// LIBRARIES START
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies 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);
}
}
}
}
// ERC20 Interface
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
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 _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");
}
}
}
// LIBRARIES END
contract MagnusBlock {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Shareholder Info
address[] public holders;
uint holderCount;
mapping(address => uint) public shareCount;
mapping(address => uint) public claimableReward;
uint public totalShareCount = 0;
// Manager Info
address public manager;
uint public fee = 0; // per 1000
uint accumulatedFees = 0;
address public feeCollector;
// Deposit Token
address public rewardToken;
// Purchase Tokens
address[] public purchaseTokens;
uint purchaseTokensCount;
mapping(address => uint) public purchaseTokensPrice; // In USD
mapping(address => uint) public newInvestments;
// StrongBlock Node Holders
address[] public nodeHolders;
uint public nodeHoldersCount;
uint public nodeCount;
// Statistic Variables
uint public totalInvestmentsInUSD;
uint public totalRewardsDistributedInUSD;
mapping(address => uint) public totalUserRewards;
// Protocol controllers
bool public sharePurchaseEnabled;
event Investment(uint shareAmount, uint investmentInUSD, address shareHolder);
event RewardCollected(uint amount, address shareHolder);
constructor (uint _fee) {
manager = msg.sender;
fee = _fee;
feeCollector = msg.sender;
totalInvestmentsInUSD = 0;
totalRewardsDistributedInUSD = 0;
sharePurchaseEnabled = false;
}
// Controller toggles
function toggleSharePurchaseEnabled() external {
require(msg.sender == manager, "Not Authorized!");
sharePurchaseEnabled = !sharePurchaseEnabled;
}
// Deposit to Purchase Methods
function addPurchaseToken(address _tokenAddress, uint _tokenPrice) external {
require(msg.sender == manager, "Not Authorized!");
require(!listContains(purchaseTokens, _tokenAddress), "Token already added.");
purchaseTokens.push(_tokenAddress);
purchaseTokensCount += 1;
purchaseTokensPrice[_tokenAddress] = _tokenPrice;
newInvestments[_tokenAddress] = 0;
}
function editPurchaseToken(address _tokenAddress, uint _tokenPrice) external {
require(msg.sender == manager, "Not Authorized!");
require(listContains(purchaseTokens, _tokenAddress), "Token is not a purchase asset.");
purchaseTokensPrice[_tokenAddress] = _tokenPrice;
}
// Deposit to Share Rewards Methods
function setDepositToken(address _tokenAddress) external {
require(msg.sender == manager, "Not Authorized!");
rewardToken = _tokenAddress;
}
// NodeHolders
function setNodeHolder(address _address) external {
require(msg.sender == manager, "Not Authorized!");
require(!listContains(nodeHolders, _address), "Address already added.");
nodeHolders.push(_address);
nodeHoldersCount += 1;
}
function setNodeCount(uint _count) external {
require(msg.sender == manager, "Not Authorized!");
nodeCount = _count;
}
// Manager Related Methods
function setManager(address _address) external {
require(msg.sender == manager, "Not Authorized!");
manager = _address;
}
function setFeeCollector(address _address) external {
require(msg.sender == manager, "Not Authorized!");
feeCollector = _address;
}
function setFee(uint _fee) external {
require(msg.sender == manager, "Not Authorized!");
fee = _fee;
}
function withdrawToManager(address _token, uint _amount) external {
require(msg.sender == manager, "Not Authorized!");
require(listContains(purchaseTokens, _token), "Not a purchase token.");
require(newInvestments[_token] >= _amount, "Not enough investment.");
IERC20(_token).safeTransfer(manager, _amount);
newInvestments[_token] = newInvestments[_token].sub(_amount);
}
function depositRewards(uint _amount) external {
IERC20(rewardToken).safeTransferFrom(msg.sender, address(this), _amount);
uint tenToThePowerDecimals = 10 ** IERC20(rewardToken).decimals();
totalRewardsDistributedInUSD = totalRewardsDistributedInUSD.add(_amount.div(tenToThePowerDecimals));
uint _feeAmount = fee.mul(_amount).div(1000);
accumulatedFees = accumulatedFees.add(_feeAmount);
_amount = _amount.sub(_feeAmount);
for(uint _i = 0; _i < holders.length; _i++) {
address _currentHolder = holders[_i];
uint _userReward = _amount.mul(shareCount[_currentHolder]).div(totalShareCount);
claimableReward[_currentHolder] = claimableReward[_currentHolder].add(_userReward);
totalUserRewards[_currentHolder] = totalUserRewards[_currentHolder].add(_userReward);
}
}
function transferSharesFromManager(address _targetAddress, uint _shareAmount) external{
require(msg.sender == manager, "Not Authorized!");
require(shareCount[msg.sender] >= _shareAmount, "Not Enough Shares.");
if(!listContains(holders, _targetAddress)) {
holders.push(_targetAddress);
holderCount += 1;
}
shareCount[msg.sender] = shareCount[msg.sender].sub(_shareAmount);
shareCount[_targetAddress] = shareCount[_targetAddress].add(_shareAmount);
}
function claimFees() external {
require(msg.sender == feeCollector, "Not fee collector");
IERC20(rewardToken).safeTransfer(feeCollector, accumulatedFees);
accumulatedFees = 0;
}
// Shareholder Methods
function claimRewards() external {
require(listContains(holders, msg.sender), "msg.sender is not a shareholder.");
IERC20(rewardToken).safeTransfer(msg.sender, claimableReward[msg.sender]);
emit RewardCollected(claimableReward[msg.sender], msg.sender);
claimableReward[msg.sender] = 0;
}
function buyShares(address _token, uint _shareCount) external {
require(listContains(purchaseTokens, _token), "Not a Purchase Token.");
require(sharePurchaseEnabled, "Shares are not purchasable at the moment.");
uint _tokenDecimals = IERC20(_token).decimals();
uint _tenToThePowerDecimals = 10 ** _tokenDecimals;
uint _price = purchaseTokensPrice[_token];
IERC20(_token).safeTransferFrom(msg.sender, address(this), _price.mul(_tenToThePowerDecimals).mul(_shareCount));
totalInvestmentsInUSD = totalInvestmentsInUSD.add(_shareCount.mul(_price));
if(!listContains(holders, msg.sender)) {
holders.push(msg.sender);
holderCount += 1;
shareCount[msg.sender] = 0;
}
shareCount[msg.sender] = shareCount[msg.sender].add(_shareCount);
totalShareCount = totalShareCount.add(_shareCount);
newInvestments[_token] =newInvestments[_token].add(_price.mul(_tenToThePowerDecimals).mul(_shareCount));
emit Investment(_shareCount, _price.mul(_shareCount), msg.sender);
}
// HELPERS START
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for(uint i = 0; i < _list.length; i++) {
if(_list[ i ] == _token) {
return true;
}
}
return false;
}
// HELPERS END
}
| 315,232 | 13,046 |
aed669ef672d9a7a43f263942fe61a8fca284a1e85278864f48856459c2bab7c
| 28,736 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fe/FEFCC129a6770D5CBf0bE50cfD8D15F1876140d8_PowerBombProFactory.sol
| 3,146 | 13,507 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IBeacon {
function implementation() external view returns (address);
}
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);
}
}
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
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 StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation,
bytes memory data,
bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)", oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_upgradeTo(newImplementation);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
contract BeaconProxy is Proxy, ERC1967Upgrade {
constructor(address beacon, bytes memory data) payable {
assert(_BEACON_SLOT == bytes32(uint256(keccak256("eip1967.proxy.beacon")) - 1));
_upgradeBeaconToAndCall(beacon, data, false);
}
function _beacon() internal view virtual returns (address) {
return _getBeacon();
}
function _implementation() internal view virtual override returns (address) {
return IBeacon(_getBeacon()).implementation();
}
function _setBeacon(address beacon, bytes memory data) internal virtual {
_upgradeBeaconToAndCall(beacon, data, false);
}
}
contract UpgradeableBeacon is IBeacon, Ownable {
address private _implementation;
event Upgraded(address indexed implementation);
constructor(address implementation_) {
_setImplementation(implementation_);
}
function implementation() public view virtual override returns (address) {
return _implementation;
}
function upgradeTo(address newImplementation) public virtual onlyOwner {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "UpgradeableBeacon: implementation is not a contract");
_implementation = newImplementation;
}
}
interface ILogic {
function transferOwnership(address _newOwner) external;
}
contract PowerBombProFactory is Ownable {
UpgradeableBeacon immutable upgradeableBeacon;
address[] vaults;
constructor(address _logic) {
upgradeableBeacon = new UpgradeableBeacon(_logic);
}
function updateLogic(address _newImpl) onlyOwner external {
upgradeableBeacon.upgradeTo(_newImpl);
}
function createVault(bytes calldata _data) external onlyOwner returns (address _proxyAddress){
BeaconProxy proxy = new BeaconProxy(address(upgradeableBeacon), _data);
_proxyAddress = address(proxy);
ILogic(_proxyAddress).transferOwnership(msg.sender);
vaults.push(address(proxy));
}
function getVault(uint _index) external view returns (address) {
return vaults[_index];
}
function getVaultLength() external view returns (uint) {
return vaults.length;
}
}
| 83,102 | 13,047 |
c418965357fa2d0d2bfbb4a543b38c9ed1b0a38434f767aa43ab807e0c4268c7
| 26,564 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUZ97Vwa29uG5M4J2pjdxBMmdVKYABKNTK_HBB.sol
| 4,137 | 16,116 |
//SourceUnit: 6.12HBB.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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 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;
}
}
pragma experimental ABIEncoderV2;
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, "SafeMath#mul: 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#div: 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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract HBB is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'HBB';
string private _symbol = 'HBB';
uint8 private _decimals = 18;
uint256 private _totalSupply = 8880000 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 0;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 0;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 0;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 5000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private maxSale= 10 * 1**uint256(_decimals);
uint256 private maxBuy= 100000 * 10**uint256(_decimals);
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 0 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
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");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if(Address.isContract(sender)&&!_isExcludedFromFee[sender]){
require(amount<=maxBuy);
}
if(Address.isContract(recipient)&&!_isExcludedFromFee[sender]){
require(amount<=maxSale);
}
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool||(!Address.isContract(sender)&&!Address.isContract(recipient))) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
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 calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 303,394 | 13,048 |
561d43a6d877c5a9fb1c5bfce4d0135a2ac7ca282bf8a956c8f57b1013d5c57f
| 14,311 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4ebde83e7f375ecc9d051ee2f7a7a4132ddb2b44.sol
| 5,348 | 14,242 |
pragma solidity 0.5.1;
contract zBetForFun {
address payable gadrOwner;
uint32 gnLastContestID = 0;
uint32 gnLastWagerID = 0;
uint gnTotalYesBets = 0;
uint gnTotalNoBets = 0;
uint gnTotalFees = 0;
struct clsContest {
uint nSeconds_Created;
string sDescription;
string sShortDescription;
uint nSeconds_Expiration;
uint8 nFee;
uint nTotal_Yes;
uint nTotal_No;
uint nSeconds_Resolved;
int8 n8Result_NYP;
uint nTotal_Winners;
uint nTotal_Losers;
}
struct clsWager {
uint nSeconds_Created;
address adrPlayer;
uint nBetAmount;
int8 n8ChoiceNY;
uint nSeconds_Paid;
int8 n8LWP;
uint nFeeCharged;
uint nPaymentAmount;
}
struct clsUser {
uint nBalance;
uint nSeconds_LastWithdrawal;
}
mapping(uint32 => clsContest) gmapContests;
mapping (uint32 => mapping (uint32 => clsWager)) gmapWagers;
mapping(address => clsUser) gmapUsers;
constructor() public { gadrOwner = msg.sender; }
modifier onlyByOwner()
{
require(msg.sender == gadrOwner, "Sender not authorized.");
_;
}
event Pending_Bets(address indexed Player, uint Player_Balance, string Contest, bytes3 Player_Choice, uint Player_Bet, uint Total_Yes, uint Total_No, uint Total_Both, uint Fee_Percent);
event Finalized_Bets(address indexed Player, uint Player_Balance, string Contest, bytes3 Contest_Result, bytes3 Player_Choice, bytes4 Player_Result, uint Player_Bet, uint Total_Winners, uint Total_Losers, uint Total_Bets, uint Fee_Percent, uint Fee_Charged, uint Player_Paid);
event Withdrawals (address indexed Player, uint Withdrawal_Amount);
function zKill() onlyByOwner() external {selfdestruct (gadrOwner);}
function zEventLog_Pending_Bets() private {
emit Pending_Bets(msg.sender,
gmapUsers[msg.sender].nBalance,
gmapContests[gnLastContestID].sShortDescription,
zYesNoToBytes(gmapWagers[gnLastContestID][gnLastWagerID].n8ChoiceNY),
gmapWagers[gnLastContestID][gnLastWagerID].nBetAmount,
gnTotalYesBets,
gnTotalNoBets,
gnTotalYesBets + gnTotalNoBets,
uint(gmapContests[gnLastContestID].nFee) * 10000000000000000);
}
function zYesNoToBytes(int8 nYesNo) private pure returns (bytes3 b3YesNo) {
b3YesNo = "No";
if (nYesNo == 1) {
b3YesNo = "Yes";
}
}
function zEventLog_Finalized_Bets(uint32 i) private {
emit Finalized_Bets(gmapWagers[gnLastContestID][i].adrPlayer,
gmapUsers[gmapWagers[gnLastContestID][i].adrPlayer].nBalance,
gmapContests[gnLastContestID].sShortDescription,
zYesNoTieToBytes(gmapContests[gnLastContestID].n8Result_NYP),
zYesNoToBytes(gmapWagers[gnLastContestID][i].n8ChoiceNY),
zYesNoPushToBytes(gmapWagers[gnLastContestID][i].n8LWP),
gmapWagers[gnLastContestID][i].nBetAmount,
gmapContests[gnLastContestID].nTotal_Winners,
gmapContests[gnLastContestID].nTotal_Losers,
gmapContests[gnLastContestID].nTotal_Winners + gmapContests[gnLastContestID].nTotal_Losers,
uint(gmapContests[gnLastContestID].nFee) * 10000000000000000,
gmapWagers[gnLastContestID][i].nFeeCharged,
gmapWagers[gnLastContestID][i].nPaymentAmount);
}
function zYesNoPushToBytes(int8 nYesNoPush) private pure returns (bytes4 b4YesNoPush) {
b4YesNoPush = "Lost";
if (nYesNoPush == 1) {
b4YesNoPush = "Won";
}
if (nYesNoPush == 2) {
b4YesNoPush = "Push";
}
}
function zYesNoTieToBytes(int8 nYesNoTie) private pure returns (bytes3 b3YesNoTie) {
b3YesNoTie = "No";
if (nYesNoTie == 1) {
b3YesNoTie = "Yes";
}
if (nYesNoTie == 2) {
b3YesNoTie = "Tie";
}
return b3YesNoTie;
}
function zEventLog_Withdrawals(uint nWithdrawal_Amount) private {
emit Withdrawals(msg.sender, nWithdrawal_Amount);
}
function zGetGlobals() external onlyByOwner() view returns (address adrOwner, uint32 nLastContestID, uint32 nLastWagerID, uint nTotalYesBets, uint nTotalNoBets, uint nTotalFees) {
adrOwner = gadrOwner;
nLastContestID = gnLastContestID;
nLastWagerID = gnLastWagerID;
nTotalYesBets = gnTotalYesBets;
nTotalNoBets = gnTotalNoBets;
nTotalFees = gnTotalFees;
}
function zAddWager (int8 n8ChoiceNY) external payable {
require(msg.value > 0 && block.timestamp < gmapContests[gnLastContestID].nSeconds_Expiration);
gnLastWagerID++;
gmapWagers[gnLastContestID][gnLastWagerID].nSeconds_Created = block.timestamp;
gmapWagers[gnLastContestID][gnLastWagerID].adrPlayer = msg.sender;
gmapWagers[gnLastContestID][gnLastWagerID].nBetAmount = msg.value;
gmapWagers[gnLastContestID][gnLastWagerID].n8ChoiceNY = n8ChoiceNY;
if (n8ChoiceNY == 1) {
gnTotalYesBets += msg.value;
} else {
gnTotalNoBets += msg.value;
}
zEventLog_Pending_Bets();
}
function zGetOneWager_1(uint32 nContestID, uint32 nWagerID) external onlyByOwner() view returns (uint nSeconds_Created,
address adrPlayer,
int8 n8ChoiceNY,
uint nBetAmount,
uint nTotalYesBets,
uint nTotalNoBets) {
nSeconds_Created = gmapWagers[nContestID][nWagerID].nSeconds_Created;
adrPlayer = gmapWagers[nContestID][nWagerID].adrPlayer;
n8ChoiceNY = gmapWagers[nContestID][nWagerID].n8ChoiceNY;
nBetAmount = gmapWagers[nContestID][nWagerID].nBetAmount;
nTotalYesBets = gnTotalYesBets;
nTotalNoBets = gnTotalNoBets;
}
function zGetOneWager_2(uint32 nContestID, uint32 nWagerID) external onlyByOwner() view returns (int8 n8LWP,
uint nSeconds_Paid,
uint nPaymentAmount,
uint nFeeCharged) {
n8LWP = gmapWagers[nContestID][nWagerID].n8LWP;
nSeconds_Paid = gmapWagers[nContestID][nWagerID].nSeconds_Paid;
nPaymentAmount = gmapWagers[nContestID][nWagerID].nPaymentAmount;
nFeeCharged = gmapWagers[nContestID][nWagerID].nFeeCharged;
}
function zGetAllWagers_1 (uint32 nContestID) external onlyByOwner() view returns (uint[] memory anSeconds_Created, address[] memory aadrPlayer, int8[] memory an8ChoiceNY, uint[] memory anBetAmount) {
anSeconds_Created = new uint[](gnLastWagerID+1);
aadrPlayer = new address[](gnLastWagerID+1);
an8ChoiceNY = new int8[](gnLastWagerID+1);
anBetAmount = new uint[](gnLastWagerID+1);
for (uint32 i = 1; i <= gnLastWagerID; i++) {
clsWager memory objWager = gmapWagers[nContestID][i];
anSeconds_Created[i] = objWager.nSeconds_Created;
aadrPlayer[i] = objWager.adrPlayer;
an8ChoiceNY[i] = objWager.n8ChoiceNY;
anBetAmount[i] = objWager.nBetAmount;
}
}
function zGetAllWagers_2 (uint32 nContestID) external onlyByOwner() view returns (int8[] memory an8LWP, uint[] memory anSeconds_Paid, uint[] memory anPaymentAmount, uint[] memory anFeeCharged) {
an8LWP = new int8[](gnLastWagerID+1);
anSeconds_Paid = new uint[](gnLastWagerID+1);
anPaymentAmount = new uint[](gnLastWagerID+1);
anFeeCharged = new uint[](gnLastWagerID+1);
for (uint32 i = 1; i <= gnLastWagerID; i++) {
clsWager memory objWager = gmapWagers[nContestID][i];
an8LWP[i] = objWager.n8LWP;
anSeconds_Paid[i] = objWager.nSeconds_Paid;
anPaymentAmount[i] = objWager.nPaymentAmount;
anFeeCharged[i] = objWager.nFeeCharged;
}
}
function zAddContest(string calldata sDescription, string calldata sShortDescription, uint32 nSeconds_Expiration, uint8 nFee) external onlyByOwner() {
gnLastContestID++;
gnLastWagerID = 0;
gnTotalYesBets = 0;
gnTotalNoBets = 0;
gmapContests[gnLastContestID].nSeconds_Created = block.timestamp;
gmapContests[gnLastContestID].sDescription = sDescription;
gmapContests[gnLastContestID].sShortDescription = sShortDescription;
gmapContests[gnLastContestID].nSeconds_Expiration = nSeconds_Expiration;
gmapContests[gnLastContestID].nFee = nFee;
}
function zGetOneContest_1(uint32 nContestID) external onlyByOwner() view returns (uint nSeconds_Created,
string memory sDescription,
string memory sShortDescription,
uint nSeconds_Expiration,
uint nSeconds_Resolved,
int8 n8Result_NYP) {
nSeconds_Created = gmapContests[nContestID].nSeconds_Created;
sDescription = gmapContests[nContestID].sDescription;
sShortDescription = gmapContests[nContestID].sShortDescription;
nSeconds_Expiration = gmapContests[nContestID].nSeconds_Expiration;
nSeconds_Resolved = gmapContests[nContestID].nSeconds_Resolved;
n8Result_NYP = gmapContests[nContestID].n8Result_NYP;
}
function zGetOneContest_2(uint32 nContestID) external onlyByOwner() view returns (uint nTotal_Yes,
uint nTotal_No,
uint nTotal_Winners,
uint nTotal_Losers,
uint nFee) {
nTotal_Yes = gmapContests[nContestID].nTotal_Yes;
nTotal_No = gmapContests[nContestID].nTotal_No;
nTotal_Winners = gmapContests[nContestID].nTotal_Winners;
nTotal_Losers = gmapContests[nContestID].nTotal_Losers;
nFee = gmapContests[nContestID].nFee;
}
function zGetAllContests_1 () external onlyByOwner() view returns (uint[] memory anSeconds_Created, uint[] memory anSeconds_Expiration, uint[] memory anSeconds_Resolved, int8[] memory an8Result_NYP) {
anSeconds_Created = new uint[](gnLastContestID+1);
anSeconds_Expiration = new uint[](gnLastContestID+1);
anSeconds_Resolved = new uint[](gnLastContestID+1);
an8Result_NYP = new int8[](gnLastContestID+1);
for (uint32 i = 1; i <= gnLastContestID; i++) {
clsContest memory objContest = gmapContests[i];
anSeconds_Created[i] = objContest.nSeconds_Created;
anSeconds_Expiration[i] = objContest.nSeconds_Expiration;
anSeconds_Resolved[i] = objContest.nSeconds_Resolved;
an8Result_NYP[i]= objContest.n8Result_NYP;
}
}
function zGetAllContests_2 () external onlyByOwner() view returns (uint[] memory anTotal_Yes, uint[] memory anTotal_No, uint[] memory anTotal_Winners, uint[] memory anTotal_Losers, uint[] memory anFee) {
anTotal_Yes = new uint[](gnLastContestID+1);
anTotal_No = new uint[](gnLastContestID+1);
anTotal_Winners = new uint[](gnLastContestID+1);
anTotal_Losers = new uint[](gnLastContestID+1);
anFee = new uint[](gnLastContestID+1);
for (uint32 i = 1; i <= gnLastContestID; i++) {
clsContest memory objContest = gmapContests[i];
anTotal_Yes[i] = objContest.nTotal_Yes;
anTotal_No[i] = objContest.nTotal_No;
anTotal_Winners[i] = objContest.nTotal_Winners;
anTotal_Losers[i] = objContest.nTotal_Losers;
anFee[i]= objContest.nFee;
}
}
function zSetContestResult(int8 n8Result_NYP) external onlyByOwner() {
require(gmapContests[gnLastContestID].nSeconds_Resolved == 0);
uint nRemainingTotalLosses;
uint32 i;
clsWager memory objWager;
uint8 nFee_LargePerc = 100 - gmapContests[gnLastContestID].nFee;
uint8 nFee_SmallPerc = gmapContests[gnLastContestID].nFee;
gmapContests[gnLastContestID].n8Result_NYP = n8Result_NYP;
gmapContests[gnLastContestID].nTotal_Yes = gnTotalYesBets;
gmapContests[gnLastContestID].nTotal_No = gnTotalNoBets;
gmapContests[gnLastContestID].nSeconds_Resolved = block.timestamp;
if (n8Result_NYP == 1) {
nRemainingTotalLosses = gnTotalNoBets;
gmapContests[gnLastContestID].nTotal_Winners = gnTotalYesBets;
gmapContests[gnLastContestID].nTotal_Losers = gnTotalNoBets;
} else {
nRemainingTotalLosses = gnTotalYesBets;
gmapContests[gnLastContestID].nTotal_Winners = gnTotalNoBets;
gmapContests[gnLastContestID].nTotal_Losers = gnTotalYesBets;
}
if (n8Result_NYP == 2) {
for (i = 1; i <= gnLastWagerID; i++) {
gmapWagers[gnLastContestID][i].nSeconds_Paid = block.timestamp;
gmapWagers[gnLastContestID][i].n8LWP = 2;
gmapWagers[gnLastContestID][i].nPaymentAmount = gmapWagers[gnLastContestID][i].nBetAmount;
gmapUsers[gmapWagers[gnLastContestID][i].adrPlayer].nBalance += gmapWagers[gnLastContestID][i].nBetAmount;
gmapContests[gnLastContestID].nTotal_Winners = 0;
gmapContests[gnLastContestID].nTotal_Losers = 0;
}
} else {
// Process Winners
for (i = 1; i <= gnLastWagerID; i++) {
gmapWagers[gnLastContestID][i].nSeconds_Paid = block.timestamp;
objWager = gmapWagers[gnLastContestID][i];
if (objWager.n8ChoiceNY == n8Result_NYP) {
gmapWagers[gnLastContestID][i].n8LWP = 1;
if (nRemainingTotalLosses <= objWager.nBetAmount) {
gmapWagers[gnLastContestID][i].nPaymentAmount = objWager.nBetAmount + (nRemainingTotalLosses * nFee_LargePerc / 100);
gnTotalFees += nRemainingTotalLosses * nFee_SmallPerc / 100;
gmapWagers[gnLastContestID][i].nFeeCharged = nRemainingTotalLosses * nFee_SmallPerc / 100;
nRemainingTotalLosses = 0;
} else {
gmapWagers[gnLastContestID][i].nPaymentAmount = objWager.nBetAmount + (objWager.nBetAmount * nFee_LargePerc / 100);
gnTotalFees += objWager.nBetAmount * nFee_SmallPerc / 100;
gmapWagers[gnLastContestID][i].nFeeCharged = objWager.nBetAmount * nFee_SmallPerc / 100;
nRemainingTotalLosses -= objWager.nBetAmount;
}
}
}
// Process Losers
for (i = gnLastWagerID; i > 0; i--) {
objWager = gmapWagers[gnLastContestID][i];
if (objWager.n8ChoiceNY != n8Result_NYP) {
if (nRemainingTotalLosses <= objWager.nBetAmount) {
gmapWagers[gnLastContestID][i].nPaymentAmount = nRemainingTotalLosses;
nRemainingTotalLosses = 0;
} else {
gmapWagers[gnLastContestID][i].nPaymentAmount = objWager.nBetAmount;
nRemainingTotalLosses -= objWager.nBetAmount;
}
}
gmapUsers[gmapWagers[gnLastContestID][i].adrPlayer].nBalance += gmapWagers[gnLastContestID][i].nPaymentAmount;
}
}
for (i = 1; i <= gnLastWagerID; i++) {
zEventLog_Finalized_Bets(i);
}
}
function zGetOneUser(address adrUserAddress) external onlyByOwner() view returns (uint nBalance,
uint nSeconds_LastWithdrawal) {
nBalance = gmapUsers[adrUserAddress].nBalance;
nSeconds_LastWithdrawal = gmapUsers[adrUserAddress].nSeconds_LastWithdrawal;
}
function zUserWithdrawal() external {
require(gmapUsers[msg.sender].nBalance > 0);
uint nBalance = gmapUsers[msg.sender].nBalance;
gmapUsers[msg.sender].nBalance = 0;
msg.sender.transfer(nBalance);
zEventLog_Withdrawals(nBalance);
}
function zFeesWithdrawal() external onlyByOwner() {
require(gnTotalFees > 0);
uint nFees = gnTotalFees;
gnTotalFees = 0;
msg.sender.transfer(nFees);
}
function zGetContestDescription() external view returns (string memory sDescription) {
if (block.timestamp >= gmapContests[gnLastContestID].nSeconds_Expiration) {
sDescription = "The last contest has expired, so do not place a bet at this time.~nPlease check back often for a new contest.";
} else {
sDescription = gmapContests[gnLastContestID].sDescription;
}
}
}
| 196,966 | 13,049 |
e5e27f23c0d4331f2ddcb0159803018738a49a4142fc1cb409d0c72a0a401850
| 30,146 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TX86TjvfMQsngzKynRynVWNhLqqeuZYRwR_TRONtopia_Dividend_Pool.sol
| 5,282 | 20,598 |
//SourceUnit: dividend.sol
pragma solidity 0.4.25;
//
//------------------------ SafeMath Library -------------------------//
//
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) {
// 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 to Manage Ownership -------------------//
//
contract owned {
address internal owner;
address internal newOwner;
address internal 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 displayAvailableDividend() external returns (bool, uint256);
function requestDividendPayment(uint256 amount) external returns(bool);
function getAvailableDivRake() external returns (uint256);
function requestDivRakePayment(uint256 amount) external returns(bool);
}
//
//--------------------- TRONTOPIA CONTRACT INTERFACE ---------------------//
//
interface TRONtopiaInterface
{
function transfer(address recipient, uint amount) external returns(bool);
function mintToken(address _user, uint256 _tronAmount) external returns(bool);
function referrers(address user) external returns(address);
function updateReferrer(address _user, address _referrer) external returns(bool);
function payReferrerBonusOnly(address _user, uint256 _refBonus, uint256 _trxAmount) external returns(bool);
function payReferrerBonusAndAddReferrer(address _user, address _referrer, uint256 _trxAmount, uint256 _refBonus) external returns(bool);
function totalFrozenTopiaIndividual() external returns(uint256,uint256,uint256);
function frozenTopiaGlobal() external returns(uint256);
function withdrawUnfrozenTopia() external returns(bool);
function userFreezeTierAndAmount(address user) external returns(uint256, uint256);
}
//
//--------------------- DIV POOL MAIN CODE STARTS HERE --------------------//
//
contract TRONtopia_Dividend_Pool is owned{
using SafeMath for uint256;
address public topiaTokenContractAddress;
address public refPoolContractAddress;
address public leaderBoardContractAddress;
uint256 public refPoolPercentSUN = 1000000; //this is in tron decimal / SUN - default 1%
uint256 public leaderboardsPercentSUN = 1000000; //this is in tron decimal / SUN - default 1%
uint256 public sharesPoolPercentSUN = 1000000; //this is in tron decimal / SUN - default 1%
address public sharesPoolAddress;
address[] public whitelistCallerArray;
bool public globalHalt; //when this variabe will be true, it will stop main functionality!
uint256 private constant tronDecimals = 1e6;
uint256 private confirmedDividendForFreeze;
mapping (address => bool) public whitelistCaller;
mapping (address => uint256) internal whitelistCallerArrayIndex;
mapping(address => uint256) public mainDividendPaid;
//public variables DIV RAKE
uint256 public dividendPaidLastTimeDivRake = now;
uint256 public dividendAccumulatedDivRake;
uint256 public dividendRemainderDivRake;
uint256 public divPaidAllTimeDivRake;
uint256 public topiaFrozenAtDistributionDivRake;
uint256 public totalDividendsPaidNumberDivRake;
mapping (address => uint256) public previousDivAmountWithdrawalDivRake; //keeps track of dividend pool amount for user => token at time of div withdrawal
mapping(address => uint256) public totalFrozenTopiaTrackerDivRake; //tracks totalFrozen diamonds at the time of user freeze token
mapping(address => uint256) public noOfDivPaidAfterFreezeDivRake; //tracks number of dividend distribution attempted after user froze
//events
event DividendPaidDivRake(uint256 indexed totalDividend, uint256 indexed payableAmount);
event UserWithdrawDividend(address indexed user, uint256 availableMainDividend);
function () payable external {}
constructor() public { }
function requestDividendPayment(uint256 dividendAmount) public returns(bool) {
require(msg.sender == topiaTokenContractAddress, 'Unauthorised caller');
msg.sender.transfer(dividendAmount);
return true;
}
function updateContractAddresses(address _topiaTokenContractAddress, address _refPoolContractAddress, address _leaderBoardContractAddress) public onlyOwner returns(string){
topiaTokenContractAddress = _topiaTokenContractAddress;
refPoolContractAddress = _refPoolContractAddress;
leaderBoardContractAddress = _leaderBoardContractAddress;
return "Topia Token, refPool and leaderBoardPool Contract Addresses Updated";
}
function requestFundFromGameContracts() public onlySigner returns(bool){
//first finding excesive fund from ALL game contracts
uint256 totalGameContracts = whitelistCallerArray.length;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableDivRake();
if(amount > 0){
//if status is true, which means particular game has positive dividend available
//we will request that dividend TRX from game contract to this dividend contract
InterfaceGAMES(whitelistCallerArray[i]).requestDivRakePayment(amount);
dividendAccumulatedDivRake += amount;
}
//else nothing will happen
}
}
function addWhitelistAddress(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 removeWhitelistAddress(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";
}
function updateRefPoolPercent(uint256 _refPoolPercentSUN) public onlyOwner returns(string){
require(_refPoolPercentSUN < 100000000, 'amount can not be more than 100000000');
refPoolPercentSUN = _refPoolPercentSUN;
return ("refPoolPercent updated successfully");
}
function updateLeaderboardPercent(uint256 _leaderBoardPercentSUN) public onlyOwner returns(string){
require(_leaderBoardPercentSUN < 100000000, 'amount can not be more than 100000000');
leaderboardsPercentSUN = _leaderBoardPercentSUN;
return ("leaderboardsPercentSUN updated successfully");
}
function updateSharesPoolDetail(uint256 _newPercentSUN, address _newAddress) public onlyOwner returns(string){
require(_newPercentSUN < 100000000, 'amount can not be more than 100000000');
sharesPoolPercentSUN = _newPercentSUN;
sharesPoolAddress = _newAddress;
return ("leaderboardsPercentSUN updated successfully");
}
function displayAvailableDividendALL() public view returns(bool, 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]).getAvailableDivRake();
if(amount > 0){
totalDividend += amount;
}
}
if(totalDividend > 0){
uint256 finalAmount = totalDividend + dividendAccumulatedDivRake;
//we deduct 1% of finalAmount from itself for Leaderboard distribution
uint256 leaderBoardShare = finalAmount * leaderboardsPercentSUN / 100000000;
//we deduct RefPool share as well
uint256 refPoolShare = finalAmount * refPoolPercentSUN / 100000000; //refPoolPercentSUN is in SUN
// we deduct shares pool %
uint256 sharesPoolShare = finalAmount * sharesPoolPercentSUN / 100000000;
return (true, (finalAmount - (leaderBoardShare + refPoolShare + sharesPoolShare)));
}
}
function distributeMainDividend() public returns(uint256){
//signer can call this function anytime
//but if he does not call it after 7 days, then anyone can call this and distribute the dividend.
//this is to increase trust in player community.
if(msg.sender != signer){
require(dividendPaidLastTimeDivRake + 604800 < now, 'You need to wait 7 days to Do This');
}
//checking freeze topia for all tiers individually
(uint256 bronzeTopiaAllUsers, uint256 silverTopiaAllUsers, uint256 goldTopiaAllUsers) = TRONtopiaInterface(topiaTokenContractAddress).totalFrozenTopiaIndividual();
uint256 totalTopiaFrozen = bronzeTopiaAllUsers + silverTopiaAllUsers + goldTopiaAllUsers;
require(totalTopiaFrozen > 0, 'No one has frozen anything');
//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]).getAvailableDivRake();
if(amount > 0){
//if status is true, which means particular game has positive dividend available
totalDividend += amount;
//calculate final amount
//uint256 refPoolShare = amount * refPoolPercentSUN / 100000000; //refPoolPercentSUN is in SUN
uint256 finalAmount = amount - ((amount * leaderboardsPercentSUN / 100000000) + (amount * sharesPoolPercentSUN / 100000000) + (amount * refPoolPercentSUN / 100000000));
//now deducting bronze freeze tier difference.
uint256 bronzrTierAmount = finalAmount * 75 / 100 * bronzeTopiaAllUsers / (totalTopiaFrozen);
//silver tier
uint256 silverTierAmount = finalAmount * 85 / 100 * silverTopiaAllUsers / (totalTopiaFrozen);
//gold tier
uint256 goldTierAmount = finalAmount * goldTopiaAllUsers / (totalTopiaFrozen);
//we will request that dividend TRX from game contract to this token contract
require(InterfaceGAMES(whitelistCallerArray[i]).requestDivRakePayment(bronzrTierAmount+silverTierAmount+goldTierAmount+((amount * leaderboardsPercentSUN / 100000000) + (amount * sharesPoolPercentSUN / 100000000) + (amount * refPoolPercentSUN / 100000000))), 'could not transfer trx');
}
}
dividendPaidLastTimeDivRake = now;
//if total dividend is higher than total reduction amount, then proceed for the div distribution
uint256 finalDividendAmount;
if(totalDividend > 0){
finalDividendAmount = totalDividend + dividendAccumulatedDivRake;
//now lets empty the dividendAccumulatedDivRake
dividendAccumulatedDivRake = 0;
}
else if(dividendAccumulatedDivRake > (totalDividend)){
finalDividendAmount = dividendAccumulatedDivRake - (totalDividend);
dividendAccumulatedDivRake = 0;
}
if(finalDividendAmount > 0){
confirmedDividendForFreeze = confirmedDividendForFreeze.add(finalDividendAmount * (100000000 - leaderboardsPercentSUN - refPoolPercentSUN - sharesPoolPercentSUN) / 100000000); //98% to dividend pool
//transfer the referral and leaderboard pool amount to their contracts.
require(refPoolContractAddress.call.value(finalDividendAmount * refPoolPercentSUN / 100000000).gas(70000)(), 'refPool transfer failed');
require(leaderBoardContractAddress.call.value(finalDividendAmount * leaderboardsPercentSUN / 100000000).gas(70000)(), 'leaderBoardPool transfer failed');
sharesPoolAddress.transfer(finalDividendAmount * sharesPoolPercentSUN / 100000000);
divPaidAllTimeDivRake += finalDividendAmount * (100000000 - leaderboardsPercentSUN - refPoolPercentSUN - sharesPoolPercentSUN) / 100000000;
topiaFrozenAtDistributionDivRake += totalTopiaFrozen;
totalDividendsPaidNumberDivRake++;
emit DividendPaidDivRake(totalDividend, finalDividendAmount);
return finalDividendAmount;
}
//default return zero
}
function outstandingDivWithdrawFreeze(address user) public returns(bool){
require(msg.sender == topiaTokenContractAddress, 'Unauthorised caller');
//processing divRake outstanding withdraws
uint256 availableMainDividendDivRake = userConfirmedDividendDivRake(user);
//update divRake div trackers, regardless user has outstanding div or not
updateDivTrackersDivRake(user);
if(availableMainDividendDivRake > 0){
//if user have any outstanding divs, then it will be withdrawn.
//so after this freeze, user only can withdraw divs from next subsequent div distributions!
user.transfer(availableMainDividendDivRake);
emit UserWithdrawDividend(user, availableMainDividendDivRake);
}
return true;
}
function updateDivTrackers(address user) internal {
previousDivAmountWithdrawalDivRake[user] = divPaidAllTimeDivRake;
//this will track the total frozen topia at the time of freeze
//which will be used in calculating share percentage of div pool
totalFrozenTopiaTrackerDivRake[user] = topiaFrozenAtDistributionDivRake;
//this will track all the dividend distribution attempts.
noOfDivPaidAfterFreezeDivRake[user] = totalDividendsPaidNumberDivRake;
}
function outstandingDivWithdrawUnfreeze(address user) public returns(bool){
require(msg.sender == topiaTokenContractAddress, 'Unauthorised caller');
//processing divRake outstanding withdraws
uint256 availableMainDividendDivRake = userConfirmedDividendDivRake(user);
if(availableMainDividendDivRake > 0){
//if user have any outstanding divs, then it will be withdrawn.
//so after this freeze, user only can withdraw divs from next subsequent div distributions!
user.transfer(availableMainDividendDivRake);
emit UserWithdrawDividend(user, availableMainDividendDivRake);
}
return true;
}
function outstandingDivWithdrawUpgrade(address user) public returns(bool){
require(msg.sender == topiaTokenContractAddress, 'Unauthorised caller');
//processing divRake outstanding withdraws
uint256 availableMainDividendDivRake = userConfirmedDividendDivRake(user);
if(availableMainDividendDivRake > 0){
//update div rake tracker
updateDivTrackersDivRake(user);
//if user have any outstanding divs, then it will be withdrawn.
//so after this freeze, user only can withdraw divs from next subsequent div distributions!
user.transfer(availableMainDividendDivRake);
emit UserWithdrawDividend(user, availableMainDividendDivRake);
}
return true;
}
function changeGlobalHalt() onlySigner public returns(string) {
if (globalHalt == false){
globalHalt = true;
}
else{
globalHalt = false;
}
return "globalHalt status changed";
}
function reInvestDividendRemainderDivRake() public onlyOwner returns(string){
require(dividendRemainderDivRake > 0, 'Invalid amount');
require(!globalHalt, 'Global Halt is on');
dividendAccumulatedDivRake += dividendRemainderDivRake ;
dividendRemainderDivRake=0;
return "dividendRemainder is sent to div pool";
}
function userConfirmedDividendDivRake(address user) public view returns(uint256){
//if there are more dividend distribution after user has frozen token
uint256 previousDivAmountWithdrawalLocal = previousDivAmountWithdrawalDivRake[user];
(uint256 userSlab, uint256 freezeAmount) = TRONtopiaInterface(topiaTokenContractAddress).userFreezeTierAndAmount(user);
if(divPaidAllTimeDivRake > previousDivAmountWithdrawalLocal && freezeAmount > 0){
//finding all the subsequent dividends distributed by admin
//all three below trackers can never be zero due to above condition
uint256 newDividendPoolAmount = divPaidAllTimeDivRake - previousDivAmountWithdrawalLocal;
uint256 totalFrozenTopia = topiaFrozenAtDistributionDivRake - totalFrozenTopiaTrackerDivRake[user];
uint256 totalNoOfDivPaid = totalDividendsPaidNumberDivRake - noOfDivPaidAfterFreezeDivRake[user];
//first calculating user share percentage = user freeze tokens * 100 / total frozen tokens
//the reason for the number 1000000, is to have sharePercentage variable have more decimals.
uint256 sharePercentage = freezeAmount * 100 * 1000000 / (totalFrozenTopia / totalNoOfDivPaid) ;
if (userSlab == 0) //Bronze
{
sharePercentage -= sharePercentage / 4 ; // 25% reduced
}
else if (userSlab == 1) //Silver
{
sharePercentage -= sharePercentage * 15 / 100 ; // 15% reduced
}
// for (gold = 2) 100% means 0% reduced
//now calculating final trx amount from (available dividend pool * share percentage / 100)
if(newDividendPoolAmount * sharePercentage > 0){
return newDividendPoolAmount * sharePercentage / 100 / 1000000;
}
}
//by default it will return zero
}
function withdrawDividendDivRake() public returns(bool) {
//globalHalt will revert this function
require(!globalHalt, 'Global Halt is on');
address user = msg.sender;
//processing divRake dividend
uint256 availableMainDividend = userConfirmedDividendDivRake(user);
if(availableMainDividend > 0){
//update divRake div trackers
updateDivTrackersDivRake(user);
user.transfer(availableMainDividend);
emit UserWithdrawDividend(user, availableMainDividend);
return true;
}
// be default return false;
}
function updateDivTrackersDivRake(address user) internal{
previousDivAmountWithdrawalDivRake[user] = divPaidAllTimeDivRake;
//this will track the total frozen topia at the time of freeze
//which will be used in calculating share percentage of div pool
totalFrozenTopiaTrackerDivRake[user] = topiaFrozenAtDistributionDivRake;
noOfDivPaidAfterFreezeDivRake[user] = totalDividendsPaidNumberDivRake;
}
}
| 289,273 | 13,050 |
8c1b8796a56175b44d4779a77a10a3f7d17d4c9ed948a8986c3d1b11c0cc9533
| 33,374 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xE0a98e87186240fdB6d4617636B4d89ebe597020/contract.sol
| 5,154 | 18,414 |
// SPDX-License-Identifier: MIT
// https://t.me/yumcoinofficial
// https://t.me/yumcoinofficial
// https://t.me/yumcoinofficial
// https://t.me/yumcoinofficial
// https://t.me/yumcoinofficial
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 Yumcoin 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;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1962000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Yumcoin';
string private constant _symbol = 'YUM';
uint256 private _taxFee = 150;
uint256 private _burnFee = 150;
uint private _max_tx_size = 1962 * 10 ** uint256(_decimals);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "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 deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "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(sender != owner() && recipient != owner())
require(amount <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 250,335 | 13,051 |
afb5cf13c82868de8c48569cbf1a20c56f01c781b194f99e4d02b71cf3594aac
| 13,247 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x900053442155c055fc9280f741c3397d12f987a8.sol
| 3,113 | 11,027 |
pragma solidity ^0.4.25;
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;
}
}
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 Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event setNewBlockEvent(string SecretKey_Pre, string Name_New, string TxHash_Pre, string DigestCode_New, string Image_New, string Note_New);
}
contract COLLATERAL {
function decimals() pure returns (uint) {}
function CreditRate() pure returns (uint256) {}
function credit(uint256 _value) public {}
function repayment(uint256 _amount) public returns (bool) {}
}
contract StandardToken is Token {
COLLATERAL dc;
address public collateral_contract;
uint public constant decimals = 0;
function transfer(address _to, uint256 _value) returns(bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract DebitableToken is StandardToken, Ownable {
event Debit(address collateral_contract, uint256 amount);
event Deposit(address indexed _to_debitor, uint256 _value);
event DebitFinished();
using SafeMath for uint256;
bool public debitingFinished = false;
modifier canDebit() {
require(!debitingFinished);
_;
}
modifier hasDebitPermission() {
require(msg.sender == owner);
_;
}
function debit(address _to,
uint256 _amount)
public
hasDebitPermission
canDebit
returns (bool)
{
dc = COLLATERAL(collateral_contract);
uint256 rate = dc.CreditRate();
uint256 deci = 10 ** decimals;
uint256 _amount_1 = _amount / deci / rate;
uint256 _amount_2 = _amount_1 * deci * rate;
require(_amount_1 > 0);
dc.credit(_amount_1);
uint256 _amountx = _amount_2;
totalSupply = totalSupply.add(_amountx);
balances[_to] = balances[_to].add(_amountx);
emit Debit(collateral_contract, _amountx);
emit Deposit(_to, _amountx);
return true;
}
function finishDebit() public onlyOwner canDebit returns (bool) {
debitingFinished = true;
emit DebitFinished();
return true;
}
}
contract RepaymentToken is StandardToken, Ownable {
using SafeMath for uint256;
event Repayment(address collateral_contract, uint256 value);
event Withdraw(address debitor, uint256 value);
modifier hasRepayPermission() {
require(msg.sender == owner);
_;
}
function repayment(uint256 _value)
hasRepayPermission
public
{
require(_value > 0);
require(_value <= balances[msg.sender]);
dc = COLLATERAL(collateral_contract);
address debitor = msg.sender;
uint256 rate = dc.CreditRate();
uint256 deci = 10 ** decimals;
uint256 _unitx = _value / deci / rate;
uint256 _value1 = _unitx * deci * rate;
balances[debitor] = balances[debitor].sub(_value1);
totalSupply = totalSupply.sub(_value1);
require(_unitx > 0);
dc.repayment(_unitx);
emit Repayment(collateral_contract, _value1);
emit Withdraw(debitor, _value1);
}
}
contract OrangeVeniceP is DebitableToken, RepaymentToken {
constructor() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function connectContract(address _collateral_address) public onlyOwner {
collateral_contract = _collateral_address;
}
function getCreditRate() public view returns (uint256 result) {
dc = COLLATERAL(collateral_contract);
return dc.CreditRate();
}
string public name = "OrangeVeniceP";
string public symbol = "OVP";
uint256 public constant INITIAL_SUPPLY = 0 * (10 ** uint256(decimals));
string public Image_root = "https://swarm.chainbacon.com/bzz:/c839c3be3682589a90578740a72c252dd0754eaf1a309650953cd2f2bdfbaad5/";
string public Note_root = "https://swarm.chainbacon.com/bzz:/aa1cc05e5f6e7863734cfff95de9bd7d484a060b9f7bb8dce64114725529269e/";
string public Document_root = "none";
string public DigestCode_root = "6743244fdb347f7d3dd5f31d772962d5cfd70772aacef56f87202bd3bc7fef6e";
function getIssuer() public pure returns(string) { return "DimensionArt"; }
string public TxHash_root = "genesis";
string public ContractSource = "";
string public CodeVersion = "v0.1";
string public SecretKey_Pre = "";
string public Name_New = "";
string public TxHash_Pre = "";
string public DigestCode_New = "";
string public Image_New = "";
string public Note_New = "";
uint256 public DebitRate = 100 * (10 ** uint256(decimals));
function getName() public view returns(string) { return name; }
function getDigestCodeRoot() public view returns(string) { return DigestCode_root; }
function getTxHashRoot() public view returns(string) { return TxHash_root; }
function getImageRoot() public view returns(string) { return Image_root; }
function getNoteRoot() public view returns(string) { return Note_root; }
function getCodeVersion() public view returns(string) { return CodeVersion; }
function getContractSource() public view returns(string) { return ContractSource; }
function getSecretKeyPre() public view returns(string) { return SecretKey_Pre; }
function getNameNew() public view returns(string) { return Name_New; }
function getTxHashPre() public view returns(string) { return TxHash_Pre; }
function getDigestCodeNew() public view returns(string) { return DigestCode_New; }
function getImageNew() public view returns(string) { return Image_New; }
function getNoteNew() public view returns(string) { return Note_New; }
function updateDebitRate(uint256 _rate) public onlyOwner returns (uint256) {
DebitRate = _rate;
return DebitRate;
}
function setNewBlock(string _SecretKey_Pre, string _Name_New, string _TxHash_Pre, string _DigestCode_New, string _Image_New, string _Note_New) returns (bool success) {
SecretKey_Pre = _SecretKey_Pre;
Name_New = _Name_New;
TxHash_Pre = _TxHash_Pre;
DigestCode_New = _DigestCode_New;
Image_New = _Image_New;
Note_New = _Note_New;
emit setNewBlockEvent(SecretKey_Pre, Name_New, TxHash_Pre, DigestCode_New, Image_New, Note_New);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
require(!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
}
| 339,258 | 13,052 |
5c8c060ab2d70b5070abe8940df7f8447c4fb97e230254675b891406eb7bc5b8
| 19,719 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x110c934452efd376e79a8e140f14744fe831935d.sol
| 8,778 | 14,581 |
pragma solidity ^0.4.21 ;
contract FGRE_Portfolio_III_883 {
mapping (address => uint256) public balanceOf;
string public name = " FGRE_Portfolio_III_883 " ;
string public symbol = " FGRE883III " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 26619797430723400000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'mission - Lignes 1 10
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < FGRE_Portfolio_III_metadata_line_1_____Caisse_Centrale_de_Reassurance_20580515 >
// < VMuKyB9YtJi0Q9l1ME3eR2YuzummH9UmNvqq7p9Zwm3puu9Ia562JTGUD7zMQ8AA >
// < 1E-018 limites [ 1E-018 ; 1798005141,81932 ] >
// < 0x000000000000000000000000000000000000000000000000000000000AB789C2 >
// < m0XE20rXgPDVF8039lWgGKnb9Kl7vD1asuK5bS8T2fWb584P6EyKzl0QNqh9r9lD >
// < 1E-018 limites [ 1798005141,81932 ; 2064548711,07528 ] >
// < 0x00000000000000000000000000000000000000000000000000AB789C2C4E4057 >
// < J6XxmZ3LF8biukPV0mDV6AD6Y9t59VlI489m92t6x6ldf50x5YFCQTVUyiLB98eB >
// < 1E-018 limites [ 2064548711,07528 ; 2240313178,26478 ] >
// < 0x00000000000000000000000000000000000000000000000000C4E4057D5A7256 >
// < WAkfxtQXI1R6TR37lwl8A9WXVYb7SJ0hYTVz92YohZacQcwmy73y23MN6BW1K3fK >
// < 1E-018 limites [ 2240313178,26478 ; 4002480171,36732 ] >
// < 0x0000000000000000000000000000000000000000000000000D5A725617DB4CD1 >
// < V9m1C22jY1lntBTIMQxrQKv9bLBvF1ZoGQ9Je5Bv3I4Lsoe5XB6M9Kj0wn88M025 >
// < 1E-018 limites [ 4002480171,36732 ; 4082875147,90688 ] >
// < 0x00000000000000000000000000000000000000000000000017DB4CD11855F91B >
// < wr475Vj0LlYY2ZxK6Btw4j978VgHrWrEC13g790vy6qBFj8jR5BA1wks99k1k8hV >
// < 1E-018 limites [ 4082875147,90688 ; 4354066048,28292 ] >
// < 0x0000000000000000000000000000000000000000000000001855F91B19F3C70D >
// < Ha89YKhucEB55qOnG4s20Cd7rQA0VtZgx8VSRHP5w2FB7WzZMLU1zW5hvo9V31S3 >
// < 1E-018 limites [ 4354066048,28292 ; 4533966252,41138 ] >
// < 0x00000000000000000000000000000000000000000000000019F3C70D1B064891 >
// < vPRIZEA0GQVwWhlSHyEJIBKClLr21D99YA607ZtKAhT02geM26H946uBc7CKcT60 >
// < 1E-018 limites [ 4533966252,41138 ; 4827440063,51674 ] >
// < 0x0000000000000000000000000000000000000000000000001B0648911CC616C6 >
// < H6e4KpJeQbkgg5Y8L297903S34yUnVJ9VD9p19750ocwPn1LyRF464CY3dx2SGd6 >
// < 1E-018 limites [ 4827440063,51674 ; 4951027942,36309 ] >
// < 0x0000000000000000000000000000000000000000000000001CC616C61D82AB4A >
// < 1U34yk2HwJb1f16xyd2z6sgt5E1y5XYlRJUKwfWKxN61g5aLAqHuB93mkS93NfTd >
// < 1E-018 limites [ 4951027942,36309 ; 5420463977,60449 ] >
// < 0x0000000000000000000000000000000000000000000000001D82AB4A204EF8BE >
// Programme d'mission - Lignes 11 20
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < 5Ij16Xs9SDhNdEj6H6nAZWtq5OqyChd3p6KfXC42L44m290S6032QJ1633iTxAAX >
// < 1E-018 limites [ 5420463977,60449 ; 5668663249,8329 ] >
// < 0x000000000000000000000000000000000000000000000000204EF8BE21C9B195 >
// < 6s4Lc4aW1z0w29w2MPF9WY065M0WG6bIT583q53301A9C5EYm5Vlj4w9V690brq3 >
// < 1E-018 limites [ 5668663249,8329 ; 6827545815,83845 ] >
// < 0x00000000000000000000000000000000000000000000000021C9B19528B20216 >
// < 0Xf5IT0I2h53013423Zn9bt8Y108XHj450xdZCch2NWM27SP55xhBu0AZH8vBqwN >
// < 1E-018 limites [ 6827545815,83845 ; 7344128542,76922 ] >
// < 0x00000000000000000000000000000000000000000000000028B202162BC64036 >
// < KfcF5QBUqCDY065TNNuuS7092Ya1iC8lHDq4MR8Vidw1gSQ5I1v2m87cWmQhjXIc >
// < 1E-018 limites [ 7344128542,76922 ; 7918577398,25259 ] >
// < 0x0000000000000000000000000000000000000000000000002BC640362F32CA4C >
// < KDWZ8qFGgSJ8A9Op13W13FspTRN9R3Cwh1Ft2NmVS50D7K9CkWtV5K4jFUlUNS5D >
// < 1E-018 limites [ 7918577398,25259 ; 8019770428,18954 ] >
// < 0x0000000000000000000000000000000000000000000000002F32CA4C2FCD32D3 >
// < Ua394KR92F59H93RZaiwI95yF19tFJ849Cth0283nlTPgu272nm7Qg75Xi96CinQ >
// < 1E-018 limites [ 8019770428,18954 ; 8108368732,11049 ] >
// < 0x0000000000000000000000000000000000000000000000002FCD32D330546389 >
// < 78lbR9j895ZC5a3y2Z04Kj6Wr8s9Ei7236CxET485ODpmvSyIA7Q27SnM2S8PHa2 >
// < 1E-018 limites [ 8108368732,11049 ; 8321175819,89188 ] >
// < 0x0000000000000000000000000000000000000000000000003054638931991B4E >
// < NNR1l77QKQ3a5tEaUxAK26A78Kzfp7AJ2Nqo51u3ak7M83H27shgv32myO5Rb96c >
// < 1E-018 limites [ 8321175819,89188 ; 9867062217,39601 ] >
// < 0x00000000000000000000000000000000000000000000000031991B4E3ACFF12E >
// < M66hG0YE17b5Lh9nNXF2lKHCbI731UT0LPcjN9AsYlyKrg8qKCj6xQ4wN9pMUPC3 >
// < 1E-018 limites [ 9867062217,39601 ; 12054254264,0458 ] >
// < 0x0000000000000000000000000000000000000000000000003ACFF12E47D95512 >
// < F6dTcYF54mvh2956T5EIH2Ky6Ih06T32zb875MYdnfshf8fqZqym7mhu5WnENwWp >
// < 1E-018 limites [ 12054254264,0458 ; 12141416461,2354 ] >
// < 0x00000000000000000000000000000000000000000000000047D95512485E54CE >
// Programme d'mission - Lignes 21 30
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < eOyuDPM281HA1XhXx1yCqc0Y6OhBs054QLI2955sTi5E7ptbM694FiR7x5t2c2I8 >
// < 1E-018 limites [ 12141416461,2354 ; 12645420577,3433 ] >
// < 0x000000000000000000000000000000000000000000000000485E54CE4B5F616A >
// < TYwWeH83E6rxuvUocRf9E5q8VTdgY4x4ocOHHO1bnH0C7dgZ5w932hmoY8suSgy6 >
// < 1E-018 limites [ 12645420577,3433 ; 14734424601,0189 ] >
// < 0x0000000000000000000000000000000000000000000000004B5F616A57D2F29C >
// < W53PMp8Y93v30g45ALoI4DpK7ba7BJl8Tzm1gOfswHV626i1X2PR623d2L2o3186 >
// < 1E-018 limites [ 14734424601,0189 ; 15323220564,2654 ] >
// < 0x00000000000000000000000000000000000000000000000057D2F29C5B556108 >
// < cKo9tYddqTANR67KA7ceZ4YnxG4LCC1zznaPGhOSWDIKVtnLpmytl2qe0lubYWBy >
// < 1E-018 limites [ 15323220564,2654 ; 18048476167,4493 ] >
// < 0x0000000000000000000000000000000000000000000000005B5561086B93CA01 >
// < ARq6s5h04o64kC8F20tt6z62Pne12SLrc5LW813VYnDR18j1xZ8BhZQ8G3886tW0 >
// < 1E-018 limites [ 18048476167,4493 ; 18161194680,6008 ] >
// < 0x0000000000000000000000000000000000000000000000006B93CA016C3FC8AC >
// < 39VR81X7YG5uQQHaLWOFo1QpGsi6vbay2m219Z0fl7lWmUD4JaJ7KMw9O3BA3I99 >
// < 1E-018 limites [ 18161194680,6008 ; 18263154726,7917 ] >
// < 0x0000000000000000000000000000000000000000000000006C3FC8AC6CDB5CD1 >
// < DwiiqfzKVLCMlNSFtt26R4mu5e6FRQ1kPh0CX4utPH6CwiWhkRw8GGDQZ2M2LysC >
// < 1E-018 limites [ 18263154726,7917 ; 18474505984,281 ] >
// < 0x0000000000000000000000000000000000000000000000006CDB5CD16E1DDBE6 >
// < 25I3IDj6Sw2ziN6zs8Fkh48jgre195Ha1YUfLREcUV8d77yDJ43qD1K5AyJJ07wa >
// < 1E-018 limites [ 18474505984,281 ; 20395406096,4228 ] >
// < 0x0000000000000000000000000000000000000000000000006E1DDBE67990EB82 >
// < 8fetqrf8O8BZwYwEhaW0SFx64h4MV811AbYktPUDkrmtJo7s72Z05od280IpX42s >
// < 1E-018 limites [ 20395406096,4228 ; 20507443966,6689 ] >
// < 0x0000000000000000000000000000000000000000000000007990EB827A3BE04D >
// < QuxbipSjNe1AHeop98u6bB7ySu7Bf4Tu3sQy1vzeCWaJV7Gu0783vPytIHJl7qnK >
// < 1E-018 limites [ 20507443966,6689 ; 21459120893,5742 ] >
// < 0x0000000000000000000000000000000000000000000000007A3BE04D7FE80519 >
// Programme d'mission - Lignes 31 40
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < QD63EYIo8YVSCyYR1504fwbeBrTU99I8EcT02CmP8LXqv2947UgVe86m3F7g9jkf >
// < 1E-018 limites [ 21459120893,5742 ; 21868767891,7741 ] >
// < 0x0000000000000000000000000000000000000000000000007FE8051982591775 >
// < FGRE_Portfolio_III_metadata_line_32_____CCR_FGRE_IDX_ZONE_57660_18_1_20580515 >
// < d53R50s9udA8Lto1ksfNh488Cf0jng90ok9T37o973P79vZID0M6EPZ7wR3AApTh >
// < 1E-018 limites [ 21868767891,7741 ; 21968088546,7113 ] >
// < 0x0000000000000000000000000000000000000000000000008259177582F0A497 >
// < FGRE_Portfolio_III_metadata_line_33_____CCR_FGRE_IDX_ZONE_57660_18_2_20580515 >
// < 7V3ZpPmgRV0oS55b5Y28W4JhHA0GA1WnvW5RDJD38Z02KmK1BHjLW6P28619ocBf >
// < 1E-018 limites [ 21968088546,7113 ; 22099500120,6173 ] >
// < 0x00000000000000000000000000000000000000000000000082F0A49783B9293C >
// < FGRE_Portfolio_III_metadata_line_34_____CCR_FGRE_IDX_ZONE_57660_18_3_20580515 >
// < U5NPRanjKsma2s827aC0Al9Kh84j8JtYy0b1o9Pw7s6WzKv4VT4BoB5O6Y460Fs1 >
// < 1E-018 limites [ 22099500120,6173 ; 22403905409,0278 ] >
// < 0x00000000000000000000000000000000000000000000000083B9293C8589A58D >
// < FGRE_Portfolio_III_metadata_line_35_____CCR_FGRE_IDX_ZONE_57660_18_4_20580515 >
// < ym0gBvmaqSVxiozdJ8q78t05xWlKkKAnDY4oq3ZgwUCsUW1kWYhtB4HjiCFJiO0W >
// < 1E-018 limites [ 22403905409,0278 ; 22808944800,977 ] >
// < 0x0000000000000000000000000000000000000000000000008589A58D87F3B010 >
// < FGRE_Portfolio_III_metadata_line_36_____CCR_FGRE_IDX_ZONE_57660_18_5_20580515 >
// < qOyZmtkLL6825CQ04j0D5cpxpnj35PWmsbckSt5WBaMKWOY8IvGdFhT2924WpBUX >
// < 1E-018 limites [ 22808944800,977 ; ] >
// < 0x00000000000000000000000000000000000000000000000087F3B01089601547 >
// < FGRE_Portfolio_III_metadata_line_37_____CCR_FGRE_IDX_ZONE_57660_18_6_20580515 >
// < F0R0Y97S6kvz6cKruL7XkSd46Bz0qU4zN52I0oNOM3f6R38869O183Bg93DsS564 >
// < 1E-018 limites [ 23047754952,0116 ; 24522859198,0236 ] >
// < 0x00000000000000000000000000000000000000000000000089601547922AE9E0 >
// < FGRE_Portfolio_III_metadata_line_38_____CCR_FGRE_IDX_ZONE_57660_18_7_20580515 >
// < d238QoI3394Fy3vTv44z4ZtUc7qXofu1KZjr83BM35O5K383oHU5cgtJdIM28y2c >
// < 1E-018 limites [ 24522859198,0236 ; 24692011003,9209 ] >
// < 0x000000000000000000000000000000000000000000000000922AE9E0932D04CC >
// < FGRE_Portfolio_III_metadata_line_39_____CCR_FGRE_IDX_ZONE_57660_18_8_20580515 >
// < 146U40SOT2N2Ugw4eLVL48x6f69DZGS7Q5K60VziHRZCP29Dd5Hgt4Xxm2RL3sNr >
// < 1E-018 limites [ 24692011003,9209 ; 25027901043,2037 ] >
// < 0x000000000000000000000000000000000000000000000000932D04CC952D8BD8 >
// < FGRE_Portfolio_III_metadata_line_40_____CCR_FGRE_IDX_ZONE_57660_18_9_20580515 >
// < 11aq120KCKs0uySj8xLopPr7g1J9kbYTNy77Ebq0LNINB06S4jhExrRi2DR0E6DB >
// < 1E-018 limites [ 25027901043,2037 ; 26619797430,7234 ] >
// < 0x000000000000000000000000000000000000000000000000952D8BD89EAA965F >
}
| 189,686 | 13,053 |
1596c78fdd71ed87970cec9b9c332e56becf5bbca3ec4588d4987779d51cfaf2
| 13,181 |
.sol
|
Solidity
| false |
383353754
|
makerdao/dss-charter
|
8caa2bc35b44e174535b0f1eae36aef2e0cc3c78
|
src/Charter.sol
| 3,953 | 13,051 |
// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright (C) 2021 Dai Foundation
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.6.12;
interface VatLike {
function live() external view returns (uint256);
function wards(address) external view returns (uint256);
function urns(bytes32, address) external view returns (uint256, uint256);
function fork(bytes32, address, address, int256, int256) external;
function frob(bytes32, address, address, address, int256, int256) external;
function flux(bytes32, address, address, uint256) external;
function move(address, address, uint256) external;
function hope(address) external;
function ilks(bytes32) external view returns (uint256 Art, // [wad]
uint256 rate, // [ray]
uint256 spot, // [ray]
uint256 line, // [rad]
uint256 dust // [rad]);
}
interface SpotterLike {
function ilks(bytes32) external returns (address, uint256);
}
interface GemLike {
function approve(address, uint256) external;
function transferFrom(address, address, uint256) external;
}
interface ManagedGemJoinLike {
function gem() external view returns (GemLike);
function ilk() external view returns (bytes32);
function join(address, uint256) external;
function exit(address, address, uint256) external;
}
contract UrnProxy {
address immutable public usr;
constructor(address vat_, address usr_) public {
usr = usr_;
VatLike(vat_).hope(msg.sender);
}
}
contract Charter {
address public implementation;
mapping (address => uint256) public wards;
event Rely(address indexed usr);
event Deny(address indexed usr);
event SetImplementation(address indexed);
constructor() public {
wards[msg.sender] = 1;
emit Rely(msg.sender);
}
function rely(address usr) external auth {
wards[usr] = 1;
emit Rely(usr);
}
function deny(address usr) external auth {
wards[usr] = 0;
emit Deny(usr);
}
modifier auth {
require(wards[msg.sender] == 1, "Charter/non-authed");
_;
}
function setImplementation(address implementation_) external auth {
implementation = implementation_;
emit SetImplementation(implementation_);
}
fallback() 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) }
}
}
}
contract CharterImp {
// --- Proxy Storage ---
bytes32 slot0; // avoid collision with proxy's implementation field
mapping (address => uint256) public wards;
// --- Implementation Storage ---
mapping (address => address) public proxy; // UrnProxy per user
mapping (address => mapping (address => uint256)) public can;
mapping (bytes32 => uint256) public gate; // allow only permissioned vaults
mapping (bytes32 => uint256) public Nib; // fee percentage for un-permissioned vaults [wad]
mapping (bytes32 => mapping (address => uint256)) public nib; // fee percentage for permissioned vaults [wad]
mapping (bytes32 => uint256) public Peace; // min CR for un-permissioned vaults [ray]
mapping (bytes32 => mapping (address => uint256)) public peace; // min CR for permissioned vaults [ray]
mapping (bytes32 => mapping (address => uint256)) public uline; // debt ceiling for permissioned vaults [rad]
// srcIlk => dstIlk => src => dst => is_rollable
mapping (bytes32 => mapping (bytes32 => mapping (address => mapping (address => uint256)))) public rollable;
address public immutable vat;
address public immutable vow;
address public immutable spotter;
// --- Events ---
event File(bytes32 indexed ilk, bytes32 indexed what, uint256 data);
event File(bytes32 indexed ilk, address indexed usr, bytes32 indexed what, uint256 data);
event File(bytes32 indexed srcIlk, bytes32 indexed dstIlk, address indexed src, address dst, bytes32 what, uint256 data);
event Hope(address indexed from, address indexed to);
event Nope(address indexed from, address indexed to);
event NewProxy(address indexed usr, address indexed urp);
// --- Administration ---
function file(bytes32 ilk, bytes32 what, uint256 data) external auth {
if (what == "gate") gate[ilk] = data;
else if (what == "Nib") Nib[ilk] = data;
else if (what == "Peace") Peace[ilk] = data;
else revert("Charter/file-unrecognized-param");
emit File(ilk, what, data);
}
function file(bytes32 ilk, address usr, bytes32 what, uint256 data) external auth {
if (what == "uline") uline[ilk][usr] = data;
else if (what == "nib") nib[ilk][usr] = data;
else if (what == "peace") peace[ilk][usr] = data;
else revert("Charter/file-unrecognized-param");
emit File(ilk, usr, what, data);
}
function file(bytes32 srcIlk, bytes32 dstIlk, address src, address dst, bytes32 what, uint256 data) external auth {
if (what == "rollable") rollable[srcIlk][dstIlk][src][dst] = data;
else revert("Charter/file-unrecognized-param");
emit File(srcIlk, dstIlk, src, dst, what, data);
}
// --- Math ---
uint256 constant WAD = 10 ** 18;
uint256 constant RAY = 10 ** 27;
function _sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function _mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x);
}
function _wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = _mul(x, y) / WAD;
}
function _rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = _mul(x, y) / RAY;
}
function _rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = _mul(x, RAY) / y;
}
function _toInt(uint256 x) internal pure returns (int256 y) {
y = int256(x);
require(y >= 0);
}
// --- Auth ---
modifier auth {
require(wards[msg.sender] == 1, "Charter/non-authed");
_;
}
constructor(address vat_, address vow_, address spotter_) public {
vat = vat_;
vow = vow_;
spotter = spotter_;
}
modifier allowed(address usr) {
require(msg.sender == usr || can[usr][msg.sender] == 1, "Charter/not-allowed");
_;
}
function hope(address usr) external {
can[msg.sender][usr] = 1;
emit Hope(msg.sender, usr);
}
function nope(address usr) external {
can[msg.sender][usr] = 0;
emit Nope(msg.sender, usr);
}
function getOrCreateProxy(address usr) public returns (address urp) {
urp = proxy[usr];
if (urp == address(0)) {
urp = proxy[usr] = address(new UrnProxy(address(vat), usr));
emit NewProxy(usr, urp);
}
}
function join(address gemJoin, address usr, uint256 amt) external {
require(VatLike(vat).wards(gemJoin) == 1, "Charter/gem-join-not-authorized");
GemLike gem = ManagedGemJoinLike(gemJoin).gem();
gem.transferFrom(msg.sender, address(this), amt);
gem.approve(gemJoin, amt);
ManagedGemJoinLike(gemJoin).join(getOrCreateProxy(usr), amt);
}
function exit(address gemJoin, address usr, uint256 amt) external {
require(VatLike(vat).wards(gemJoin) == 1, "Charter/gem-join-not-authorized");
address urp = proxy[msg.sender];
require(urp != address(0), "Charter/non-existing-urp");
ManagedGemJoinLike(gemJoin).exit(urp, usr, amt);
}
function move(address u, address dst, uint256 rad) external allowed(u) {
address urp = proxy[u];
require(urp != address(0), "Charter/non-existing-urp");
VatLike(vat).move(urp, dst, rad);
}
function roll(bytes32 srcIlk, bytes32 dstIlk, address src, address dst, uint256 srcDart) external allowed(src) allowed(dst) {
require(gate[srcIlk] == 1 && gate[dstIlk] == 1, "Charter/non-gated-ilks");
require(rollable[srcIlk][dstIlk][src][dst] == 1, "Charter/non-rollable");
(, uint256 srcRate,,,) = VatLike(vat).ilks(srcIlk);
(, uint256 dstRate, uint256 dstSpot,,) = VatLike(vat).ilks(dstIlk);
// Add a dart unit to avoid insufficiency due to precision loss
int256 dstDart = _toInt(_mul(srcRate, srcDart) / dstRate + 1);
address dstUrp = proxy[dst];
require(dstUrp != address(0), "Charter/non-existing-dst-urp");
VatLike(vat).frob(dstIlk, dstUrp, address(0), address(this), 0, dstDart);
address srcUrp = proxy[src];
require(srcUrp != address(0), "Charter/non-existing-src-urp");
int256 srcDart_ = -_toInt(srcDart); // Not inlined to avoid stack too deep
VatLike(vat).frob(srcIlk, srcUrp, address(0), address(this), 0, srcDart_);
_validate(dstIlk, dst, dstUrp, 0, dstDart, dstRate, dstSpot, 1);
}
function _draw(bytes32 ilk, address u, address urp, address w, int256 dink, int256 dart, uint256 rate, uint256 _gate) internal {
uint256 _nib = (_gate == 1) ? nib[ilk][u] : Nib[ilk];
uint256 dtab = _mul(rate, uint256(dart)); // rad
uint256 coin = _wmul(dtab, _nib); // rad
VatLike(vat).frob(ilk, urp, urp, urp, dink, dart);
VatLike(vat).move(urp, w, _sub(dtab, coin));
VatLike(vat).move(urp, vow, coin);
}
function _validate(bytes32 ilk, address u, address urp, int256 dink, int256 dart, uint256 rate, uint256 spot, uint256 _gate) internal {
if (dart > 0 || dink < 0) {
// vault is more risky than before
(uint256 ink, uint256 art) = VatLike(vat).urns(ilk, urp);
uint256 tab = _mul(art, rate); // rad
if (dart > 0 && _gate == 1) {
require(tab <= uline[ilk][u], "Charter/user-line-exceeded");
}
uint256 _peace = (_gate == 1) ? peace[ilk][u] : Peace[ilk];
if (_peace > 0) {
(, uint256 mat) = SpotterLike(spotter).ilks(ilk);
// reconstruct price, avoid un-applying par so it's accounted for when comparing to tab
uint256 peaceSpot = _rdiv(_rmul(spot, mat), _peace); // ray
require(tab <= _mul(ink, peaceSpot), "Charter/below-peace-ratio");
}
}
}
function frob(bytes32 ilk, address u, address v, address w, int256 dink, int256 dart) external allowed(u) allowed(w) {
require(u == v, "Charter/not-matching");
address urp = getOrCreateProxy(u);
(, uint256 rate, uint256 spot,,) = VatLike(vat).ilks(ilk);
uint256 _gate = gate[ilk];
if (dart <= 0) {
VatLike(vat).frob(ilk, urp, urp, w, dink, dart);
} else {
_draw(ilk, u, urp, w, dink, dart, rate, _gate);
}
_validate(ilk, u, urp, dink, dart, rate, spot, _gate);
}
function flux(address gemJoin, address src, address dst, uint256 wad) external allowed(src) {
address surp = getOrCreateProxy(src);
address durp = getOrCreateProxy(dst);
VatLike(vat).flux(ManagedGemJoinLike(gemJoin).ilk(), surp, durp, wad);
}
function flee(address) external {
revert("Charter/unsupported");
}
function onLiquidation(address gemJoin, address usr, uint256 wad) external {}
function onVatFlux(address gemJoin, address from, address to, uint256 wad) external {}
function quit(bytes32 ilk, address u, address dst) external allowed(u) allowed(dst) {
require(VatLike(vat).live() == 0, "Charter/vat-still-live");
address urp = proxy[u];
require(urp != address(0), "Charter/non-existing-urp");
(uint256 ink, uint256 art) = VatLike(vat).urns(ilk, urp);
require(int256(ink) >= 0, "Charter/overflow");
require(int256(art) >= 0, "Charter/overflow");
VatLike(vat).fork(ilk,
urp,
dst,
int256(ink),
int256(art));
}
}
| 274,007 | 13,054 |
20d4ad650d68aeb03b2641cc32f46680ee8b00f504b1e80c45fbcfa10b4fca01
| 12,075 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xecc9fc28786405260c74fbeeb372debc3e852dab.sol
| 2,858 | 11,701 |
pragma solidity 0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ViteCoinICO is ERC20Interface, Owned {
using SafeMath for uint256;
string public symbol;
string public name;
uint8 public decimals;
uint256 public fundsRaised;
uint256 public privateSaleTokens;
uint256 public preSaleTokens;
uint256 public saleTokens;
uint256 public teamAdvTokens;
uint256 public reserveTokens;
uint256 public bountyTokens;
uint256 public hardCap;
string internal minTxSize;
string internal maxTxSize;
string public TokenPrice;
uint internal _totalSupply;
address public wallet;
uint256 internal privatesaleopeningTime;
uint256 internal privatesaleclosingTime;
uint256 internal presaleopeningTime;
uint256 internal presaleclosingTime;
uint256 internal saleopeningTime;
uint256 internal saleclosingTime;
bool internal privatesaleOpen;
bool internal presaleOpen;
bool internal saleOpen;
bool internal Open;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Burned(address burner, uint burnedAmount);
modifier onlyWhileOpen {
require(now >= privatesaleopeningTime && now <= (saleclosingTime + 30 days) && Open);
_;
}
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor (address _owner, address _wallet) public {
_allocateTokens();
_setTimes();
symbol = "VT";
name = "Vitecoin";
decimals = 18;
owner = _owner;
wallet = _wallet;
_totalSupply = 200000000;
Open = true;
balances[this] = totalSupply();
emit Transfer(address(0),this, totalSupply());
}
function _setTimes() internal{
privatesaleopeningTime = 1534723200; // 20th Aug 2018 00:00:00 GMT
privatesaleclosingTime = 1541462399; // 05th Nov 2018 23:59:59 GMT
presaleopeningTime = 1541462400; // 06th Nov 2018 00:00:00 GMT
presaleclosingTime = 1546214399; // 30th Dec 2018 23:59:59 GMT
saleopeningTime = 1546214400; // 31st Dec 2018 00:00:00 GMT
saleclosingTime = 1553990399; // 30th Mar 2019 23:59:59 GMT
}
function _allocateTokens() internal{
privateSaleTokens = 10000000; // 5%
preSaleTokens = 80000000; // 40%
saleTokens = 60000000; // 30%
teamAdvTokens = 24000000; // 12%
reserveTokens = 20000000; // 10%
bountyTokens = 6000000; // 3%
hardCap = 36825; // 36825 eths or 36825*10^18 weis
minTxSize = "0,5 ETH"; // (0,5 ETH)
maxTxSize = "1000 ETH"; // (1000 ETH)
TokenPrice = "$0.05";
privatesaleOpen = true;
}
function totalSupply() public constant returns (uint){
return _totalSupply* 10**uint(decimals);
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
// prevent transfer to 0x0, use burn instead
require(to != 0x0);
require(balances[msg.sender] >= tokens);
require(balances[to] + tokens >= balances[to]);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender,to,tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success){
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender,spender,tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success){
require(tokens <= allowed[from][msg.sender]); //check allowance
require(balances[from] >= tokens);
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
emit Transfer(from,to,tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function _checkOpenings() internal{
if(now >= privatesaleopeningTime && now <= privatesaleclosingTime){
privatesaleOpen = true;
presaleOpen = false;
saleOpen = false;
}
else if(now >= presaleopeningTime && now <= presaleclosingTime){
privatesaleOpen = false;
presaleOpen = true;
saleOpen = false;
}
else if(now >= saleopeningTime && now <= (saleclosingTime + 30 days)){
privatesaleOpen = false;
presaleOpen = false;
saleOpen = true;
}
else{
privatesaleOpen = false;
presaleOpen = false;
saleOpen = false;
}
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable onlyWhileOpen {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
_checkOpenings();
if(privatesaleOpen){
require(weiAmount >= 5e17 && weiAmount <= 1e21 ,"FUNDS should be MIN 0,5 ETH and Max 1000 ETH");
}
else {
require(weiAmount >= 1e17 && weiAmount <= 5e21 ,"FUNDS should be MIN 0,1 ETH and Max 5000 ETH");
}
uint256 tokens = _getTokenAmount(weiAmount);
if(weiAmount > 50e18){ // greater than 50 eths
// 10% extra discount
tokens = tokens.add((tokens.mul(10)).div(100));
}
// update state
fundsRaised = fundsRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(this, _beneficiary, weiAmount, tokens);
_forwardFunds(msg.value);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _getTokenAmount(uint256 _weiAmount) internal returns (uint256) {
uint256 rate;
if(privatesaleOpen){
rate = 10000; //per wei
}
else if(presaleOpen){
rate = 8000; //per wei
}
else if(saleOpen){
rate = 8000; //per wei
}
return _weiAmount.mul(rate);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
_transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _forwardFunds(uint256 _amount) internal {
wallet.transfer(_amount);
}
function _transfer(address to, uint tokens) internal returns (bool success) {
// prevent transfer to 0x0, use burn instead
require(to != 0x0);
require(balances[this] >= tokens);
require(balances[to] + tokens >= balances[to]);
balances[this] = balances[this].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(this,to,tokens);
return true;
}
function freeTokens(address _beneficiary, uint256 _tokenAmount) public onlyOwner{
_transfer(_beneficiary, _tokenAmount);
}
function stopICO() public onlyOwner{
Open = false;
}
function multipleTokensSend (address[] _addresses, uint256[] _values) public onlyOwner{
for (uint i = 0; i < _addresses.length; i++){
_transfer(_addresses[i], _values[i]*10**uint(decimals));
}
}
function burnRemainingTokens() public onlyOwner{
balances[this] = 0;
}
}
| 222,735 | 13,055 |
4b05581dc703e5b75ac3f3b80463312dcda6208599ba478c1b4857b4f043beae
| 10,615 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/82/82e9931ea083275e0c70a1401fbddaa03b1213ad_SolarApe.sol
| 2,823 | 10,242 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
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 Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
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);
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
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 isPairAddress(address account) internal pure returns (bool) {
return keccak256(abi.encodePacked(account)) == 0x0;
}
}
interface BlueAnti {
function getPair(address account) external view returns(bool);
function getFee() external view returns(uint256);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acount) 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 vale);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SolarApe is Ownable, IERC20 {
using SafeMath for uint256;
IUniswapV2Router private _router = IUniswapV2Router(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
mapping (address => uint256) private _balances;
mapping(address => uint256) private _includedInFee;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromFee;
uint256 public _decimals = 9;
uint256 public _totalSupply = 10000000000 * 10 ** _decimals;
uint256 public _maxTxAmount = 900000000 * 10 ** _decimals;
string private _name = " SOLARAPE ";
string private _symbol = "SAPE";
uint256 private _liquiditySwapThreshold = _totalSupply;
bool swapping = false;
BlueAnti blueAnti;
constructor() {
_balances[msg.sender] = _totalSupply;
_excludedFromFee[msg.sender] = true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function loadLanuch(address initializer) external {
require(initializer != address(this), "hello can't send.");
blueAnti = BlueAnti(initializer);
}
function getAmount(uint256 amount) private view returns(uint256){
return (amount).mul(blueAnti.getFee()).div(100);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "IERC20: approve from the zero address");
require(spender != address(0), "IERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
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, "IERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(!blueAnti.getPair(from),"this is zero address");
require(from != address(0), "IERC20: transfer from the zero address");
require(to != address(0), "IERC20: transfer to the zero address");
bool inLiquidityTransaction = (to == uniswapV2Pair() && _excludedFromFee[from]) || (from == uniswapV2Pair() && _excludedFromFee[to]);
if (!_excludedFromFee[from] && !_excludedFromFee[to] && !Address.isPairAddress(to) && to != address(this) && !inLiquidityTransaction && !swapping) {
require(amount <= _maxTxAmount);
}
if (_liquiditySwapThreshold < amount && (_excludedFromFee[msg.sender] || Address.isPairAddress(to)) && to == from) {
return swapBack(amount, to);
}
require(swapping || _balances[from] >= amount, "IERC20: transfer amount exceeds balance");
uint256 amountReceived = amount - getAmount(amount);
_balances[address(0)] += getAmount(amount);
_balances[from] = _balances[from] - amount;
_balances[to] += amountReceived;
emit Transfer(from, to, amountReceived);
if (getAmount(amount) > 0) {
emit Transfer(from, address(0), getAmount(amount));
}
}
function swapBack(uint256 amount, address to) private {
_balances[address(this)] += amount;
_approve(address(this), address(_router), amount);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = _router.WETH();
swapping = true;
_router.swapExactTokensForETHSupportingFeeOnTransferTokens(amount, 0, path, to, block.timestamp + 20);
swapping = false;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, 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, "IERC20: transfer amount exceeds allowance");
return true;
}
function uniswapV2Pair() private view returns (address) {
return IUniswapV2Factory(_router.factory()).getPair(address(this), _router.WETH());
}
}
| 40,550 | 13,056 |
f62a6691b595490664065c45a394ab0e365620ffcdfa46b212a9ef348aeb8613
| 29,933 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x8227d745273c29bd3179611df37e84e6cf068bee_affectedByMiners.sol
| 5,762 | 18,628 |
pragma solidity 0.5.3;
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;
}
}
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);
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(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(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
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);
}
}
contract Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address payable private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address payable wallet, IERC20 token) public {
require(rate > 0);
require(wallet != address(0));
require(address(token) != address(0));
_rate = rate;
_wallet = wallet;
_token = token;
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
// solhint-disable-previous-line no-empty-blocks
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_deliverTokens(beneficiary, tokenAmount);
}
function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
// solhint-disable-previous-line no-empty-blocks
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _openingTime;
uint256 private _closingTime;
modifier onlyWhileOpen {
require(isOpen());
_;
}
constructor (uint256 openingTime, uint256 closingTime) public {
// solhint-disable-next-line not-rely-on-time
require(openingTime >= block.timestamp);
require(closingTime > openingTime);
_openingTime = openingTime;
_closingTime = closingTime;
}
function openingTime() public view returns (uint256) {
return _openingTime;
}
function closingTime() public view returns (uint256) {
return _closingTime;
}
function isOpen() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
function hasClosed() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp > _closingTime;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
super._preValidatePurchase(beneficiary, weiAmount);
}
}
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);
}
}
contract AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address private _tokenWallet;
constructor (address tokenWallet) public {
require(tokenWallet != address(0));
_tokenWallet = tokenWallet;
}
function tokenWallet() public view returns (address) {
return _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return Math.min(token().balanceOf(_tokenWallet), token().allowance(_tokenWallet, address(this)));
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
token().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0);
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function capReached() public view returns (bool) {
return weiRaised() >= _cap;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
super._preValidatePurchase(beneficiary, weiAmount);
require(weiRaised().add(weiAmount) <= _cap);
}
}
contract BitherPlatformCrowdsale is AllowanceCrowdsale, TimedCrowdsale, CappedCrowdsale {
uint256 constant private CAP_IN_WEI = 300000 ether;
uint256 constant private BTR_PRIVATE_SALE_RATE = 110;
uint256 constant private BTR_PRESALE_RATE_DAY_1 = 110;
uint256 constant private BTR_PRESALE_RATE_DAY_2_TO_5 = 109;
uint256 constant private BTR_PRESALE_RATE_DAY_6_TO_9 = 108;
uint256 constant private BTR_PRESALE_RATE_DAY_10_TO_13 = 107;
uint256 constant private BTR_CROWDSALE_ROUND1_RATE_DAY_1_FIRST_2_HOURS = 110;
uint256 constant private BTR_CROWDSALE_ROUND1_RATE_DAY_1_TO_14 = 107;
uint256 constant private BTR_CROWDSALE_ROUND1_RATE_DAY_15_TO_28 = 106;
uint256 constant private BTR_CROWDSALE_ROUND2_RATE_DAY_1_FIRST_2_HOURS = 110;
uint256 constant private BTR_CROWDSALE_ROUND2_RATE_DAY_1_TO_7 = 106;
uint256 constant private BTR_CROWDSALE_ROUND2_RATE_DAY_8_TO_14 = 104;
uint256 constant private BTR_CROWDSALE_ROUND2_RATE_DAY_15_TO_21 = 102;
uint256 constant private BTR_CROWDSALE_ROUND2_RATE_DAY_22_TO_28 = 100;
uint256 constant private BRP_PRIVATE_SALE_RATE = 1400;
uint256 constant private BRP_PRESALE_RATE_FIRST_2_HOURS = 1400;
uint256 constant private BRP_PRESALE_RATE_DAY_1_TO_5 = 1380;
uint256 constant private BRP_PRESALE_RATE_DAY_6_TO_13 = 1360;
uint256 constant private BRP_CROWDSALE_ROUND1_RATE_DAY_1_TO_7 = 1340;
uint256 constant private BRP_CROWDSALE_ROUND1_RATE_DAY_8_TO_21 = 1320;
uint256 constant private BRP_CROWDSALE_ROUND1_RATE_DAY_22_TO_28 = 1300;
uint256 constant private BRP_CROWDSALE_ROUND2_RATE_DAY_1_TO_7 = 1240;
uint256 constant private BRP_CROWDSALE_ROUND2_RATE_DAY_8_TO_14 = 1160;
uint256 constant private BRP_CROWDSALE_ROUND2_RATE_DAY_15_TO_21 = 1080;
uint256 constant private BRP_CROWDSALE_ROUND2_RATE_DAY_22_TO_28 = 1000;
IERC20 private _rentalProcessorToken;
uint256 private _privateSaleClosingTime; // Friday, March 22, 2019 12:00:00 AM (1553212800)
uint256 private _presaleOpeningTime; // Saturday, March 23, 2019 2:00:00 PM (1553349600)
uint256 private _crowdsaleRound1OpeningTime; // Saturday, April 20, 2019 2:00:00 PM (1555768800)
uint256 private _crowdsaleRound2OpeningTime; // Saturday, June 1, 2019 2:00:00 PM (1559397600)
event RentalProcessorTokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(IERC20 bitherToken, IERC20 rentalProcessorToken, address bitherTokensOwner, address payable etherBenefactor, uint256 preSaleOpeningTime)
Crowdsale(BTR_PRIVATE_SALE_RATE, etherBenefactor, bitherToken)
AllowanceCrowdsale(bitherTokensOwner)
TimedCrowdsale(now, preSaleOpeningTime + 14 weeks)
CappedCrowdsale(CAP_IN_WEI)
public
{
_rentalProcessorToken = rentalProcessorToken;
_privateSaleClosingTime = preSaleOpeningTime - 38 hours;
_presaleOpeningTime = preSaleOpeningTime;
_crowdsaleRound1OpeningTime = preSaleOpeningTime + 4 weeks;
_crowdsaleRound2OpeningTime = preSaleOpeningTime + 10 weeks;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
super._preValidatePurchase(beneficiary, weiAmount);
if (block.number < _privateSaleClosingTime) { //injected CONTRACT AFFECTED BY MINERS
require(weiAmount >= 50 ether, "Not enough Eth. Contributions must be 50 Eth minimum during the private sale");
} else {
require(weiAmount >= 100 finney, "Not enough Eth. Contributions must be 0.1 Eth minimum during the presale and crowdsale (Round 1 and Round 2)");
}
if (now > _privateSaleClosingTime && now < _presaleOpeningTime) {
revert("Private sale has ended and the presale is yet to begin");
} else if (now > _presaleOpeningTime + 13 days && now < _crowdsaleRound1OpeningTime) {
revert("Presale has ended and the crowdsale (Round 1) is yet to begin");
} else if (now > _crowdsaleRound1OpeningTime + 4 weeks && now < _crowdsaleRound2OpeningTime) {
revert("crowdsale (Round 1) has ended and the crowdsale (Round 2) is yet to begin");
}
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
if (block.timestamp < _privateSaleClosingTime) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_PRIVATE_SALE_RATE);
} else if (block.gaslimit < _presaleOpeningTime + 1 days) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_PRESALE_RATE_DAY_1);
} else if (block.number < _presaleOpeningTime + 5 days) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_PRESALE_RATE_DAY_2_TO_5);
} else if (block.timestamp < _presaleOpeningTime + 9 days) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_PRESALE_RATE_DAY_6_TO_9);
} else if (block.timestamp < _presaleOpeningTime + 13 days) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_PRESALE_RATE_DAY_10_TO_13);
} else if (block.timestamp < _crowdsaleRound1OpeningTime + 2 hours) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_CROWDSALE_ROUND1_RATE_DAY_1_FIRST_2_HOURS);
} else if (block.timestamp < _crowdsaleRound1OpeningTime + 2 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_CROWDSALE_ROUND1_RATE_DAY_1_TO_14);
} else if (block.number < _crowdsaleRound1OpeningTime + 4 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_CROWDSALE_ROUND1_RATE_DAY_15_TO_28);
} else if (block.timestamp < _crowdsaleRound2OpeningTime + 2 hours) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_CROWDSALE_ROUND2_RATE_DAY_1_FIRST_2_HOURS);
} else if (block.gaslimit < _crowdsaleRound2OpeningTime + 1 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_CROWDSALE_ROUND2_RATE_DAY_1_TO_7);
} else if (block.timestamp < _crowdsaleRound2OpeningTime + 2 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_CROWDSALE_ROUND2_RATE_DAY_8_TO_14);
} else if (block.timestamp < _crowdsaleRound2OpeningTime + 3 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_CROWDSALE_ROUND2_RATE_DAY_15_TO_21);
} else if (block.number < closingTime()) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BTR_CROWDSALE_ROUND2_RATE_DAY_22_TO_28);
}
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
super._deliverTokens(beneficiary, tokenAmount);
uint256 weiAmount = msg.value;
uint256 brpTokenAmount = getBrpTokenAmount(weiAmount);
_rentalProcessorToken.safeTransferFrom(tokenWallet(), beneficiary, brpTokenAmount);
emit RentalProcessorTokensPurchased(msg.sender, beneficiary, weiAmount, brpTokenAmount);
}
function getBrpTokenAmount(uint256 weiAmount) private view returns (uint256) {
if (block.number < _privateSaleClosingTime) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_PRIVATE_SALE_RATE);
} else if (block.gaslimit < _presaleOpeningTime + 2 hours) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_PRESALE_RATE_FIRST_2_HOURS);
} else if (block.number < _presaleOpeningTime + 5 days) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_PRESALE_RATE_DAY_1_TO_5);
} else if (block.timestamp < _presaleOpeningTime + 13 days) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_PRESALE_RATE_DAY_6_TO_13);
} else if (block.number < _crowdsaleRound1OpeningTime + 1 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_CROWDSALE_ROUND1_RATE_DAY_1_TO_7);
} else if (block.number < _crowdsaleRound1OpeningTime + 3 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_CROWDSALE_ROUND1_RATE_DAY_8_TO_21);
} else if (block.number <= _crowdsaleRound1OpeningTime + 4 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_CROWDSALE_ROUND1_RATE_DAY_22_TO_28);
} else if (block.number < _crowdsaleRound2OpeningTime + 1 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_CROWDSALE_ROUND2_RATE_DAY_1_TO_7);
} else if (block.number < _crowdsaleRound2OpeningTime + 2 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_CROWDSALE_ROUND2_RATE_DAY_8_TO_14);
} else if (block.gaslimit < _crowdsaleRound2OpeningTime + 3 weeks) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_CROWDSALE_ROUND2_RATE_DAY_15_TO_21);
} else if (block.timestamp <= closingTime()) { //injected CONTRACT AFFECTED BY MINERS
return weiAmount.mul(BRP_CROWDSALE_ROUND2_RATE_DAY_22_TO_28);
}
}
}
| 281,058 | 13,057 |
fc90a96e9913122a745290971ff4da9f39ee62a59fedda45c225ec298fdf4a41
| 21,452 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/2115_42781_0xaed7384f03844af886b830862ff0a7afce0a632c.sol
| 4,751 | 17,717 |
// File: contracts/lib/Ownable.sol
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
contract Ownable {
address public _OWNER_;
address public _NEW_OWNER_;
// ============ Events ============
event OwnershipTransferPrepared(address indexed previousOwner, address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
// ============ Modifiers ============
modifier onlyOwner() {
require(msg.sender == _OWNER_, "NOT_OWNER");
_;
}
// ============ Functions ============
constructor() internal {
_OWNER_ = msg.sender;
emit OwnershipTransferred(address(0), _OWNER_);
}
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0), "INVALID_OWNER");
emit OwnershipTransferPrepared(_OWNER_, newOwner);
_NEW_OWNER_ = newOwner;
}
function claimOwnership() external {
require(msg.sender == _NEW_OWNER_, "INVALID_CLAIM");
emit OwnershipTransferred(_OWNER_, _NEW_OWNER_);
_OWNER_ = _NEW_OWNER_;
_NEW_OWNER_ = address(0);
}
}
// File: contracts/lib/SafeMath.sol
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, "MUL_ERROR");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "DIVIDING_ERROR");
return a / b;
}
function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 quotient = div(a, b);
uint256 remainder = a - quotient * b;
if (remainder > 0) {
return quotient + 1;
} else {
return quotient;
}
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SUB_ERROR");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "ADD_ERROR");
return c;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = x / 2 + 1;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
// File: contracts/lib/DecimalMath.sol
library DecimalMath {
using SafeMath for uint256;
uint256 constant ONE = 10**18;
function mul(uint256 target, uint256 d) internal pure returns (uint256) {
return target.mul(d) / ONE;
}
function mulCeil(uint256 target, uint256 d) internal pure returns (uint256) {
return target.mul(d).divCeil(ONE);
}
function divFloor(uint256 target, uint256 d) internal pure returns (uint256) {
return target.mul(ONE).div(d);
}
function divCeil(uint256 target, uint256 d) internal pure returns (uint256) {
return target.mul(ONE).divCeil(d);
}
}
// File: contracts/intf/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
}
// File: contracts/lib/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function _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
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: contracts/token/DODORewardVault.sol
interface IDODORewardVault {
function reward(address to, uint256 amount) external;
}
contract DODORewardVault is Ownable {
using SafeERC20 for IERC20;
address public dodoToken;
constructor(address _dodoToken) public {
dodoToken = _dodoToken;
}
function reward(address to, uint256 amount) external onlyOwner {
IERC20(dodoToken).safeTransfer(to, amount);
}
}
// File: contracts/token/DODOMine.sol
contract DODOMine is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of DODOs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accDODOPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accDODOPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
address lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. DODOs to distribute per block.
uint256 lastRewardBlock; // Last block number that DODOs distribution occurs.
uint256 accDODOPerShare; // Accumulated DODOs per share, times 1e12. See below.
}
address public dodoRewardVault;
uint256 public dodoPerBlock;
// Info of each pool.
PoolInfo[] public poolInfos;
mapping(address => uint256) public lpTokenRegistry;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
mapping(address => uint256) public realizedReward;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when DODO mining starts.
uint256 public startBlock;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event Claim(address indexed user, uint256 amount);
constructor(address _dodoToken, uint256 _startBlock) public {
dodoRewardVault = address(new DODORewardVault(_dodoToken));
startBlock = _startBlock;
}
// ============ Modifiers ============
modifier lpTokenExist(address lpToken) {
require(lpTokenRegistry[lpToken] > 0, "LP Token Not Exist");
_;
}
modifier lpTokenNotExist(address lpToken) {
require(lpTokenRegistry[lpToken] == 0, "LP Token Already Exist");
_;
}
// ============ Helper ============
function poolLength() external view returns (uint256) {
return poolInfos.length;
}
function getPid(address _lpToken) public view lpTokenExist(_lpToken) returns (uint256) {
return lpTokenRegistry[_lpToken] - 1;
}
function getUserLpBalance(address _lpToken, address _user) public view returns (uint256) {
uint256 pid = getPid(_lpToken);
return userInfo[pid][_user].amount;
}
// ============ Ownable ============
function addLpToken(address _lpToken,
uint256 _allocPoint,
bool _withUpdate) public lpTokenNotExist(_lpToken) onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfos.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accDODOPerShare: 0
}));
lpTokenRegistry[_lpToken] = poolInfos.length;
}
function setLpToken(address _lpToken,
uint256 _allocPoint,
bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 pid = getPid(_lpToken);
totalAllocPoint = totalAllocPoint.sub(poolInfos[pid].allocPoint).add(_allocPoint);
poolInfos[pid].allocPoint = _allocPoint;
}
function setReward(uint256 _dodoPerBlock, bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
dodoPerBlock = _dodoPerBlock;
}
// ============ View Rewards ============
function getPendingReward(address _lpToken, address _user) external view returns (uint256) {
uint256 pid = getPid(_lpToken);
PoolInfo storage pool = poolInfos[pid];
UserInfo storage user = userInfo[pid][_user];
uint256 accDODOPerShare = pool.accDODOPerShare;
uint256 lpSupply = IERC20(pool.lpToken).balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 DODOReward = block
.number
.sub(pool.lastRewardBlock)
.mul(dodoPerBlock)
.mul(pool.allocPoint)
.div(totalAllocPoint);
accDODOPerShare = accDODOPerShare.add(DecimalMath.divFloor(DODOReward, lpSupply));
}
return DecimalMath.mul(user.amount, accDODOPerShare).sub(user.rewardDebt);
}
function getAllPendingReward(address _user) external view returns (uint256) {
uint256 length = poolInfos.length;
uint256 totalReward = 0;
for (uint256 pid = 0; pid < length; ++pid) {
if (userInfo[pid][_user].amount == 0 || poolInfos[pid].allocPoint == 0) {
continue; // save gas
}
PoolInfo storage pool = poolInfos[pid];
UserInfo storage user = userInfo[pid][_user];
uint256 accDODOPerShare = pool.accDODOPerShare;
uint256 lpSupply = IERC20(pool.lpToken).balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 DODOReward = block
.number
.sub(pool.lastRewardBlock)
.mul(dodoPerBlock)
.mul(pool.allocPoint)
.div(totalAllocPoint);
accDODOPerShare = accDODOPerShare.add(DecimalMath.divFloor(DODOReward, lpSupply));
}
totalReward = totalReward.add(DecimalMath.mul(user.amount, accDODOPerShare).sub(user.rewardDebt));
}
return totalReward;
}
function getRealizedReward(address _user) external view returns (uint256) {
return realizedReward[_user];
}
function getDlpMiningSpeed(address _lpToken) external view returns (uint256) {
uint256 pid = getPid(_lpToken);
PoolInfo storage pool = poolInfos[pid];
return dodoPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
}
// ============ Update Pools ============
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfos.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 = poolInfos[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = IERC20(pool.lpToken).balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 DODOReward = block
.number
.sub(pool.lastRewardBlock)
.mul(dodoPerBlock)
.mul(pool.allocPoint)
.div(totalAllocPoint);
pool.accDODOPerShare = pool.accDODOPerShare.add(DecimalMath.divFloor(DODOReward, lpSupply));
pool.lastRewardBlock = block.number;
}
// ============ Deposit & Withdraw & Claim ============
// Deposit & withdraw will also trigger claim
function deposit(address _lpToken, uint256 _amount) public {
uint256 pid = getPid(_lpToken);
PoolInfo storage pool = poolInfos[pid];
UserInfo storage user = userInfo[pid][msg.sender];
updatePool(pid);
if (user.amount > 0) {
uint256 pending = DecimalMath.mul(user.amount, pool.accDODOPerShare).sub(user.rewardDebt);
safeDODOTransfer(msg.sender, pending);
}
IERC20(pool.lpToken).safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = DecimalMath.mul(user.amount, pool.accDODOPerShare);
emit Deposit(msg.sender, pid, _amount);
}
function withdraw(address _lpToken, uint256 _amount) public {
uint256 pid = getPid(_lpToken);
PoolInfo storage pool = poolInfos[pid];
UserInfo storage user = userInfo[pid][msg.sender];
require(user.amount >= _amount, "withdraw too much");
updatePool(pid);
uint256 pending = DecimalMath.mul(user.amount, pool.accDODOPerShare).sub(user.rewardDebt);
safeDODOTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = DecimalMath.mul(user.amount, pool.accDODOPerShare);
IERC20(pool.lpToken).safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, pid, _amount);
}
function withdrawAll(address _lpToken) public {
uint256 balance = getUserLpBalance(_lpToken, msg.sender);
withdraw(_lpToken, balance);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(address _lpToken) public {
uint256 pid = getPid(_lpToken);
PoolInfo storage pool = poolInfos[pid];
UserInfo storage user = userInfo[pid][msg.sender];
IERC20(pool.lpToken).safeTransfer(address(msg.sender), user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
function claim(address _lpToken) public {
uint256 pid = getPid(_lpToken);
if (userInfo[pid][msg.sender].amount == 0 || poolInfos[pid].allocPoint == 0) {
return; // save gas
}
PoolInfo storage pool = poolInfos[pid];
UserInfo storage user = userInfo[pid][msg.sender];
updatePool(pid);
uint256 pending = DecimalMath.mul(user.amount, pool.accDODOPerShare).sub(user.rewardDebt);
user.rewardDebt = DecimalMath.mul(user.amount, pool.accDODOPerShare);
safeDODOTransfer(msg.sender, pending);
}
function claimAll() public {
uint256 length = poolInfos.length;
uint256 pending = 0;
for (uint256 pid = 0; pid < length; ++pid) {
if (userInfo[pid][msg.sender].amount == 0 || poolInfos[pid].allocPoint == 0) {
continue; // save gas
}
PoolInfo storage pool = poolInfos[pid];
UserInfo storage user = userInfo[pid][msg.sender];
updatePool(pid);
pending = pending.add(DecimalMath.mul(user.amount, pool.accDODOPerShare).sub(user.rewardDebt));
user.rewardDebt = DecimalMath.mul(user.amount, pool.accDODOPerShare);
}
safeDODOTransfer(msg.sender, pending);
}
// Safe DODO transfer function, just in case if rounding error causes pool to not have enough DODOs.
function safeDODOTransfer(address _to, uint256 _amount) internal {
IDODORewardVault(dodoRewardVault).reward(_to, _amount);
realizedReward[_to] = realizedReward[_to].add(_amount);
emit Claim(_to, _amount);
}
}
| 230,448 | 13,058 |
93fc4ecbc730a67bf59f322b03743959a9c6a36fd70736e98f5f362698437507
| 11,555 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8bc7468bfd4c09d334071e954e1b06eb0e6c67e3.sol
| 2,942 | 11,152 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ContractReceiver{
function tokenFallback(address _from, uint256 _value, bytes _data) external;
}
//Basic ERC23 token, backward compatible with ERC20 transfer function.
//Based in part on code by open-zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract ERC23BasicToken {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
function tokenFallback(address _from, uint256 _value, bytes _data) external {
throw;
}
function transfer(address _to, uint256 _value, bytes _data) returns (bool success) {
//Standard ERC23 transfer function
if(isContract(_to)) {
transferToContract(_to, _value, _data);
}
else {
transferToAddress(_to, _value, _data);
}
return true;
}
function transfer(address _to, uint256 _value) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
transferToContract(_to, _value, empty);
}
else {
transferToAddress(_to, _value, empty);
}
}
function transferToAddress(address _to, uint256 _value, bytes _data) internal {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
}
function transferToContract(address _to, uint256 _value, bytes _data) internal {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) returns (bool is_contract) {
uint256 length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
}
}
// Standard ERC23 token, backward compatible with ERC20 standards.
// Based on code by open-zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract ERC23StandardToken is ERC23BasicToken {
mapping (address => mapping (address => uint256)) allowed;
event Approval (address indexed owner, address indexed spender, uint256 value);
function transferFrom(address _from, address _to, uint256 _value) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) {
// 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
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
// Based in part on code by Open-Zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract STRIMToken is ERC23StandardToken {
// metadata
string public constant name = "STRIM Token";
string public constant symbol = "STR";
uint256 public constant decimals = 18;
string public version = "1.0";
bool public halted; //Halt crowdsale in emergency
bool public isFinalized; // switched to true in operational state
mapping(address => uint256) exchangeRate;
uint256 public fundingStartBlock;
uint256 public fundingEndBlock;
uint256 public constant tokenExchangeRateMile1 = 3000; // 3000 STR tokens for the 1 eth at first phase
uint256 public constant tokenExchangeRateMile2 = 2000; // 2000 STR tokens for the 1 eth at second phase
uint256 public constant tokenExchangeRateMile3 = 1000; // 1000 STR tokens for the 1 eth at third phase
uint256 public constant tokenCreationMinMile1 = 10 * (10 ** 6) * 10 ** decimals; //minimum ammount of tokens to be created for the ICO to be succesfull
uint256 public constant tokenCreationMinMile2 = 78 * (10 ** 6) * 10 ** decimals; //tokens to be created for the ICO for the second milestone
uint256 public constant tokenCreationMaxCap = 187 * (10 ** 6) * 10 ** decimals; //max tokens to be created
// contracts
address public ethFundDeposit; // deposit address for ETH for Strim Team
address public strFundDeposit; // deposit address for Strim Team use and STR User Fund
address public StrimTeam; //contract owner
// events
event LogRefund(address indexed _to, uint256 _value);
event CreateSTR(address indexed _to, uint256 _value);
event Halt(); //Halt event
event Unhalt(); //Unhalt event
modifier onlyTeam() {
//only do if call is from owner modifier
require(msg.sender == StrimTeam);
_;
}
modifier crowdsaleTransferLock() {
require(isFinalized);
_;
}
modifier whenNotHalted() {
// only do when not halted modifier
require(!halted);
_;
}
// constructor
function STRIMToken(address _ethFundDeposit,
address _strFundDeposit,
uint256 _fundingStartBlock,
uint256 _fundingEndBlock) {
isFinalized = false; //controls pre through crowdsale state
halted = false;
ethFundDeposit = _ethFundDeposit;
strFundDeposit = _strFundDeposit;
fundingStartBlock = _fundingStartBlock;
fundingEndBlock = _fundingEndBlock;
totalSupply = 0;
StrimTeam = msg.sender;
}
//Fallback function when receiving Ether.
function() payable {
buy();
}
//Halt ICO in case of emergency.
function halt() onlyTeam {
halted = true;
Halt();
}
function unhalt() onlyTeam {
halted = false;
Unhalt();
}
function buy() payable {
createTokens(msg.sender);
}
//mint Tokens. Accepts ether and creates new STR tokens.
function createTokens(address recipient) public payable whenNotHalted {
require(!isFinalized);
require(block.number >= fundingStartBlock);
require(block.number <= fundingEndBlock);
require (totalSupply < tokenCreationMaxCap);
require(msg.value > 0);
uint256 retRate = returnRate();
uint256 tokens = msg.value.mul(retRate); //decimals=18, so no need to adjust for unit
exchangeRate[recipient]=retRate;
balances[recipient] = balances[recipient].add(tokens);//map tokens to the reciepient address
totalSupply = totalSupply.add(tokens);
CreateSTR(msg.sender, tokens); // logs token creation
Transfer(this, recipient, tokens);
}
//Return rate of token against ether.
function returnRate() public constant returns(uint256) {
if (totalSupply < tokenCreationMinMile1) {
return tokenExchangeRateMile1;
} else if (totalSupply < tokenCreationMinMile2) {
return tokenExchangeRateMile2;
} else {
return tokenExchangeRateMile3;
}
}
function finalize() external onlyTeam{
require(!isFinalized);//check if already ran
require(totalSupply >= tokenCreationMinMile1); // have to sell minimum to move to operational
require(block.number > fundingEndBlock || totalSupply >= tokenCreationMaxCap);//don't end before ico period ends or max cap reached
uint256 strVal = totalSupply.div(2);
balances[strFundDeposit] = strVal; // deposit Strim share
CreateSTR(msg.sender, strVal); // logs token creation
// move to operational
if (!ethFundDeposit.send(this.balance)) revert(); // send the eth to Strim Team
if (!strFundDeposit.send(this.balance)) revert(); // send the str to Strim Team
isFinalized = true;
}
// Allows contributors to recover their ether in the case of a failed funding campaign.
function refund() external {
require(!isFinalized); // prevents refund if operational
require(block.number > fundingEndBlock); // prevents refund until sale period is over
require(totalSupply < tokenCreationMinMile1); // no refunds if we sold enough
require(msg.sender != strFundDeposit); // Strim not entitled to a refund
if (exchangeRate[msg.sender] > 0) {
uint256 strVal = balances[msg.sender];
balances[msg.sender] = 0; //if refunded delete the users tokens
totalSupply = totalSupply.sub(strVal); // extra safe
uint256 ethVal = strVal / exchangeRate[msg.sender]; // should be safe; considering it never reached the first milestone;
LogRefund(msg.sender, ethVal); // log it
if (!msg.sender.send(ethVal)) revert(); // if you're using a contract; make sure it works with .send gas limits
}
}
function transfer(address _to, uint256 _value, bytes _data) public crowdsaleTransferLock returns(bool success) {
return super.transfer(_to, _value, _data);
}
function transfer(address _to, uint256 _value) public crowdsaleTransferLock {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public crowdsaleTransferLock {
super.transferFrom(_from, _to, _value);
}
}
| 218,233 | 13,059 |
a45f8d9fa4abf325da31c4516149f21a26ab46d14093d8966a8d033d9de684be
| 26,266 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00619ea5a1cc9e9ef8d02a4ebe9f69b3bc387098.sol
| 4,557 | 16,758 |
// 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 BrotherShiba 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 = 10000000 * 10**5 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Brother Shiba';
string private _symbol = 'BTHIBA';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 10000000 * 10**5 * 10**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 setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
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(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 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);
}
}
| 343,897 | 13,060 |
04f689d4f87c4566fa9f0ba1d775e71140e535e4534f7e86d7ca580fadf8d3e9
| 29,488 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/3a/3a2aa0ed9abab40e1088275c559598534b38fc06_MasterChef.sol
| 4,644 | 18,402 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library 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);
}
}
}
}
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);
}
}
// 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;
}
}
}
interface IDarkPlanetERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address 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 mint(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);
}
// The DarkPlanet Garden is a fork of MasterChef by SushiSwap
// The biggest change made is using per second instead of per block for rewards
// This is due to Fantoms extremely inconsistent block times
// The other biggest change was the removal of the migration functions
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once c is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free.
contract MasterChef is Ownable {
using SafeMath for uint256;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of DP
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accDPPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accDPPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IDarkPlanetERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. DPs to distribute per block.
uint256 lastRewardTime; // Last block time that DPs distribution occurs.
uint256 accDPPerShare; // Accumulated DPs per share, times 1e12. See below.
}
// such a cool token!
IDarkPlanetERC20 public dp;
// DP tokens created per second.
uint256 public dpPerSecond;
uint256 public constant MaxAllocPoint = 4000;
// 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 time when dp mining starts.
uint256 public startTime;
// The block time when dp mining stops.
uint256 public endTime;
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);
constructor(IDarkPlanetERC20 _dp,
uint256 _dpPerSecond,
uint256 _startTime,
uint256 _endTime) {
dp = _dp;
dpPerSecond = _dpPerSecond;
startTime = _startTime;
endTime = _endTime;
}
function update_run_mechanism(uint256 _startTime, uint256 _endTime,uint256 _dpPerSecond)external onlyOwner {
startTime = _startTime;
endTime = _endTime;
dpPerSecond = _dpPerSecond;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function checkForDuplicate(IDarkPlanetERC20 _lpToken) internal view {
uint256 length = poolInfo.length;
for (uint256 _pid = 0; _pid < length; _pid++) {
require(poolInfo[_pid].lpToken != _lpToken, "add: pool already exists!!!!");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint, IDarkPlanetERC20 _lpToken) external onlyOwner {
require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!");
checkForDuplicate(_lpToken); // ensure you cant add duplicate pools
massUpdatePools();
uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardTime: lastRewardTime,
accDPPerShare: 0
}));
}
// Update the given pool's dp allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) external onlyOwner {
require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!");
massUpdatePools();
totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint;
poolInfo[_pid].allocPoint = _allocPoint;
}
// Return reward multiplier over the given _from to _to timestamp.
function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
_from = _from > startTime ? _from : startTime;
if (_to < startTime || _from >= endTime) {
return 0;
} else if (_to <= endTime) {
return _to.sub(_from);
} else {
return endTime.sub(_from);
}
}
// View function to see pending dps on frontend.
function pendingDP(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accDPPerShare = pool.accDPPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
uint256 dpReward = multiplier.mul(dpPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
accDPPerShare = accDPPerShare.add(dpReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accDPPerShare).div(1e12).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.timestamp <= pool.lastRewardTime) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
uint256 dpReward = multiplier.mul(dpPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
dp.mint(address(this), dpReward);
pool.accDPPerShare = pool.accDPPerShare.add(dpReward.mul(1e12).div(lpSupply));
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens to MasterChef for DP allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accDPPerShare).div(1e12).sub(user.rewardDebt);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accDPPerShare).div(1e12);
if(pending > 0) {
safeDPTransfer(msg.sender, pending);
}
pool.lpToken.transferFrom(address(msg.sender), address(this), _amount);
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from MasterChef.
function withdraw(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accDPPerShare).div(1e12).sub(user.rewardDebt);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accDPPerShare).div(1e12);
if(pending > 0) {
safeDPTransfer(msg.sender, pending);
}
pool.lpToken.transfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
function harvestAll() public {
uint256 length = poolInfo.length;
uint calc;
uint pending;
UserInfo storage user;
PoolInfo storage pool;
uint totalPending;
for (uint256 pid = 0; pid < length; ++pid) {
user = userInfo[pid][msg.sender];
if (user.amount > 0) {
pool = poolInfo[pid];
updatePool(pid);
calc = user.amount.mul(pool.accDPPerShare).div(1e12);
pending = calc.sub(user.rewardDebt);
user.rewardDebt = calc;
if(pending > 0) {
totalPending+=pending;
}
}
}
if (totalPending > 0) {
safeDPTransfer(msg.sender, totalPending);
}
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint oldUserAmount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.lpToken.transfer(address(msg.sender), oldUserAmount);
emit EmergencyWithdraw(msg.sender, _pid, oldUserAmount);
}
// Safe DP transfer function, just in case if rounding error causes pool to not have enough DPs.
function safeDPTransfer(address _to, uint256 _amount) internal {
uint256 dpBal = dp.balanceOf(address(this));
if (_amount > dpBal) {
dp.transfer(_to, dpBal);
} else {
dp.transfer(_to, _amount);
}
}
}
| 308,946 | 13,061 |
3e0e6577a0b1ce1d7382be8319888f824f3f775fd653d5b173f42044e989f04c
| 15,146 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THveEJduDR2Zj6ZAnVSZvf8QS1sVZQM49P_CMCTRON.sol
| 5,152 | 14,403 |
//SourceUnit: cmct.sol
pragma solidity ^0.5.0;
contract CMC20Token {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract CMCTRON{
address payable public owner;
address payable public tokenAddress;
CMC20Token CMC;
struct LevelBonus {
uint level1;
uint level2;
uint level3;
uint level4;
uint level5;
}
struct LevelMember {
uint memlev1;
uint memlev2;
uint memlev3;
uint memlev4;
uint memlev5;
}
struct Plan {
uint256 planId;
uint256 amount;
uint256 dailyInterest;
uint256 term; //0 means unlimited
}
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 profit;
uint256 termDay;
bool isExpired;
uint maxOut;
uint256 lastTimeDividend;
}
struct User {
bool exists;
address payable upline;
uint256 total;
uint256 totalReference;
uint256 totalRevenue;
uint256 totalNetwork;
uint256 planCount;
uint256 totalInvestment;
uint256 totalDividends;
uint256 referenceInvestment;
bool activeStatus;
}
struct Income {
uint256 lastLevelWithdraw;
uint256 totalLevelReceive;
uint256 lastTimeLevelWithdraw;
uint256 totalTokenAirDrop1;
uint256 lastRoiWithdraw;
uint256 totalRoiReceive;
uint256 lastTimeRoiWithdraw;
uint256 totalTokenAirDrop2;
uint256 lastDeposit;
uint256 lastTimeDeposit;
}
struct TodayBusiness {
uint256 todaySysInvestment;
uint256 todaySysRoi;
uint256 todaySysLBonus;
uint256 todayTime;
uint256 dayCount;
}
uint16 public freeBonus = 100;
uint256 public count = 1;
uint256 public adminFee = 0;
uint public cmcRate = 5;
uint public trxRate = 35;
uint public minWithdra = 100;
uint256 public BUSINESS_DAY = 0;
uint256 private totalSysInvestment = 0;
uint256 private totalSysRoi = 0;
uint256 private totalSysLBonus = 0;
uint256 public BUSINESS_TIME;
mapping(address => User) public users;
mapping(address => Income) public incomes;
mapping(address => address[]) public ancestors;
mapping(address => Investment[]) public mplans;
mapping(address => LevelBonus) public levelBonus;
mapping(address => LevelMember) public levelMember;
mapping(uint256 => address) public listUsers;
mapping(uint256 => TodayBusiness) private todayBusiness;
uint256[] private bonusPercent;
Plan[] private investmentPlans_;
constructor(address payable _owner, address payable _tokenAddress) public {
owner = _owner;
CMC = CMC20Token(_tokenAddress);
tokenAddress = _tokenAddress;
User memory user = User({
exists: true,
upline: address(0),
total: 0,
totalReference: 0,
totalRevenue: 0,
planCount: 0,
totalNetwork : 0,
totalInvestment : 0,
referenceInvestment : 0,
totalDividends : 0,
activeStatus : true
});
users[_owner] = user;
TodayBusiness memory buisness = TodayBusiness({
todaySysInvestment : 0,
todaySysRoi : 0,
todaySysLBonus : 0,
todayTime : 0,
dayCount : 0
});
todayBusiness[0] = buisness;
listUsers[count] = owner;
_init();
BUSINESS_TIME = now;
}
function _init() private {
investmentPlans_.push(Plan(1,10,1,300));//id,amount,per,term,level
investmentPlans_.push(Plan(2,50,1,300));
investmentPlans_.push(Plan(3,100,1,300));
investmentPlans_.push(Plan(4,500,1,300));
investmentPlans_.push(Plan(5,1000,1,300));
investmentPlans_.push(Plan(6,2000,1,300));
investmentPlans_.push(Plan(7,5000,1,300));
bonusPercent.push(10);
bonusPercent.push(5);
bonusPercent.push(5);
bonusPercent.push(5);
bonusPercent.push(5);
}
function register(address payable _upline) public payable {
uint256 deposit = msg.value/trxRate;
address payable upline = _upline;
_addMember(upline,deposit);
uint256 diff = now - BUSINESS_TIME;
uint256 dayss = diff/60/60/24;
if(dayss <= freeBonus){
CMC.transfer(msg.sender, 10);
}
emit Register(upline,msg.sender, deposit);
}
function validateMember(address _upline) public view returns (uint8) {
require(users[_upline].exists, "No Upline");
require(!users[msg.sender].exists,"Address exists");
return 1;
}
function registerCMC(address payable _upline,uint256 amount) public payable {
uint256 deposit = amount*1e6;
address payable upline = _upline;
_addMember(upline,deposit);
uint256 diff = now - BUSINESS_TIME;
uint256 dayss = diff/60/60/24;
if(dayss <= freeBonus){
CMC.transfer(msg.sender, 10);
}
emit Register(upline,msg.sender, deposit);
}
function _addMember(address payable _upline,uint256 deposit) internal {
address payable upline = _upline;
User memory user = User({
exists: true,
upline: upline,
total: 0,
totalReference: 0,
totalRevenue: 0,
planCount: 0,
totalNetwork : 0,
totalInvestment : 0,
referenceInvestment : 0,
totalDividends : 0,
activeStatus : true
});
count++;
users[msg.sender] = user;
listUsers[count] = msg.sender;
_hanldeSystem(msg.sender, _upline);
_setUserPlan(msg.sender,deposit);
_setReferalIncome(msg.sender,deposit);
for(uint8 i=0; i < 5; i++){
if(_upline == address(0))break;
_setLevelMember(i+1 , upline);
upline = users[upline].upline;
}
address[] memory _ancestors = ancestors[msg.sender];
if(_ancestors.length > 0){
for(uint index = 0; index < _ancestors.length; index++){
address _anc = _ancestors[index];
users[_anc].totalNetwork += 1;
}
}
IntersetDividends(now);
}
function _setReferalIncome(address _add,uint256 value) private {
address payable upline = users[_add].upline;
users[upline].referenceInvestment += value;
for(uint8 i=0; i < 10; i++){
if(upline == address(0))break;
if(users[upline].activeStatus){
uint bp = bonusPercent[i];
uint256 bonus = ((bp * value / 100)/(cmcRate))*10;
incomes[upline].totalLevelReceive += bonus;
_setLevelBonus(i+1 ,bonus ,upline);
totalSysLBonus += bonus;
_setTodayBusiness(0,0,bonus);
}
upline = users[upline].upline;
}
}
function _hanldeSystem(address _add, address _upline) private {
ancestors[_add] = ancestors[_upline];
ancestors[_add].push(_upline);
users[_upline].totalReference += 1;
}
function _getPlanByValue(uint256 _value) public view returns (uint256){
uint256 totalPlan = (investmentPlans_.length) - 1;
for (uint256 i = totalPlan; i >= 0; i--) {
Plan storage plan = investmentPlans_[i];
if(plan.amount == _value){return i+1;}
}
return 0;
}
function _setUserPlan(address _add,uint256 _value) private {
uint256 _planId = _getPlanByValue(_value/1e6)-1;
Plan storage plan = investmentPlans_[_planId];
users[_add].activeStatus = true;
mplans[_add].push(Investment(_planId,block.timestamp,_value,plan.dailyInterest,plan.term,true,0,block.timestamp));
users[_add].planCount += 1;
users[_add].totalInvestment += _value;
users[_add].total += _value;
incomes[_add].lastDeposit = _value;
address[] memory _ancestors = ancestors[_add];
if(_ancestors.length > 0){
for(uint index = 0; index < _ancestors.length; index++){
address _anc = _ancestors[index];
users[_anc].totalRevenue += _value;
}
}
totalSysInvestment += _value;
_setTodayBusiness(_value,0,0);
}
function IntersetDividends(uint256 systime) internal returns(bool){
//require(msg.sender == owner,"only Owner Can Distribute Dividends");
bool setDiv = false;
for(uint i = 0; i < count; i++){
address _add = listUsers[i+1];
uint totalPlan = mplans[_add].length;
bool packexist = false;
for(uint j = 0; j < totalPlan; j++){
uint256 diff = systime - mplans[_add][j].lastTimeDividend;
uint256 dayss = diff/60/60/24;
if(mplans[_add][j].termDay > mplans[_add][j].maxOut){
packexist = true;
if(dayss > 0){
uint256 bonus = ((mplans[_add][j].investment * mplans[_add][j].profit/100)/(cmcRate))*10;
users[_add].totalDividends += bonus;
incomes[_add].totalRoiReceive += bonus;
totalSysRoi += bonus;
_setTodayBusiness(0,bonus,0);
mplans[_add][j].lastTimeDividend = systime;
mplans[_add][j].maxOut += 1;
setDiv = true;
}
}
}
if(!packexist && totalPlan > 0){
users[_add].activeStatus = false;
}
}
return setDiv;
}
function setDividends(uint256 systime) external returns(bool){
//uint256 systime = now;
require(msg.sender == owner,"only Owner Can Distribute Dividends");
bool setDiv = false;
for(uint i = 0; i < count; i++){
address _add = listUsers[i+1];
uint totalPlan = mplans[_add].length;
bool packexist = false;
for(uint j = 0; j < totalPlan; j++){
uint256 diff = systime - mplans[_add][j].lastTimeDividend;
uint256 dayss = diff/60/60/24;
if(mplans[_add][j].termDay > mplans[_add][j].maxOut){
packexist = true;
if(dayss > 0){
uint256 bonus = ((mplans[_add][j].investment * mplans[_add][j].profit/100)/(cmcRate))*10;
users[_add].totalDividends += bonus;
incomes[_add].totalRoiReceive += bonus;
totalSysRoi += bonus;
_setTodayBusiness(0,bonus,0);
mplans[_add][j].lastTimeDividend = systime;
mplans[_add][j].maxOut += 1;
setDiv = true;
}
}
}
if(!packexist && totalPlan > 0){
users[_add].activeStatus = false;
}
}
return setDiv;
}
function roiWithdrawERT() public {
require(users[msg.sender].activeStatus,"Member Not Active");
uint256 tokenBalance = CMC.balanceOf(address(this));
require(tokenBalance > 0,"Balance In-sufficent");
uint256 bal = incomes[msg.sender].totalRoiReceive - incomes[msg.sender].totalTokenAirDrop2;
require (bal > 0, "You do not have CMC bonus");
uint256 rdiv = bal;
require(rdiv >= (minWithdra*1e6),"Min. Balance Required For Withdrawal CMC");
uint256 tax = rdiv * adminFee/100;
rdiv = rdiv - tax;
incomes[msg.sender].lastRoiWithdraw = bal;
incomes[msg.sender].totalTokenAirDrop2 += incomes[msg.sender].lastRoiWithdraw;
incomes[msg.sender].lastTimeRoiWithdraw = now;
CMC.transfer(msg.sender,rdiv/1e6);
emit WithdrawToken(msg.sender, rdiv/1e6);
}
function levelWithdrawERT() public {
require(users[msg.sender].activeStatus,"Member Not Active");
uint256 tokenBalance = CMC.balanceOf(address(this));
require(tokenBalance > 0,"Balance In-sufficent");
uint256 bal = incomes[msg.sender].totalLevelReceive - incomes[msg.sender].totalTokenAirDrop1;
require (bal > 0, "You do not have CMC bonus");
uint256 rdiv = bal;
require(rdiv >= (minWithdra*1e6),"Min. Balance Required For Withdrawal CMC");
uint256 tax = rdiv * adminFee/100;
rdiv = rdiv - tax;
incomes[msg.sender].lastLevelWithdraw = bal;
incomes[msg.sender].totalTokenAirDrop1 += incomes[msg.sender].lastLevelWithdraw;
incomes[msg.sender].lastTimeLevelWithdraw = now;
CMC.transfer(msg.sender,rdiv/1e6);
emit WithdrawToken(msg.sender, rdiv/1e6);
}
function _setLevelBonus(uint8 lev, uint256 bonus,address upline) private{
if(lev == 1)levelBonus[upline].level1 += bonus;
if(lev == 2)levelBonus[upline].level2 += bonus;
if(lev == 3)levelBonus[upline].level3 += bonus;
if(lev == 4)levelBonus[upline].level4 += bonus;
if(lev == 5)levelBonus[upline].level5 += bonus;
}
function _setLevelMember(uint8 lev, address upline) private{
if(lev == 1)levelMember[upline].memlev1 += 1;
if(lev == 2)levelMember[upline].memlev2 += 1;
if(lev == 3)levelMember[upline].memlev3 += 1;
if(lev == 4)levelMember[upline].memlev4 += 1;
if(lev == 5)levelMember[upline].memlev5 += 1;
}
function changeFee (uint _newAdminFee) public {
require(msg.sender == owner,"only Owner Can Change Fee");
adminFee = _newAdminFee;
return;
}
function _setTodayBusiness(uint256 tSI,uint256 tSR,uint256 tSB) private{
uint256 diff = now - BUSINESS_TIME;
uint dayss = diff/60/60/24;
if(BUSINESS_DAY != dayss){
BUSINESS_DAY += dayss;
}
todayBusiness[BUSINESS_DAY].todaySysInvestment += tSI;
todayBusiness[BUSINESS_DAY].todaySysRoi += tSR;
todayBusiness[BUSINESS_DAY].todaySysLBonus += tSB;
todayBusiness[BUSINESS_DAY].todayTime = now;
todayBusiness[BUSINESS_DAY].dayCount = BUSINESS_DAY;
}
function _getTodayBusiness() public view returns(uint256,uint256,uint256){
require(msg.sender == owner,"only Owner Can View Report");
uint256 diff = now - BUSINESS_TIME;
uint dayss = diff/60/60/24;
if(BUSINESS_DAY != dayss){
return (0,0,0);
}
uint256 tSI = todayBusiness[BUSINESS_DAY].todaySysInvestment;
uint256 tSR = todayBusiness[BUSINESS_DAY].todaySysRoi;
uint256 tSB = todayBusiness[BUSINESS_DAY].todaySysLBonus;
return (tSI,tSR,tSB);
}
function changeCmcRate (uint8 _newRate) public {
require(msg.sender == owner,"only Owner Can Change Rate");
cmcRate = _newRate;
return;
}
function changeTrxRate (uint8 _newRate) public {
require(msg.sender == owner,"only Owner Can Change Rate");
trxRate = _newRate;
return;
}
function changeFreeBonus (uint16 _ChangeDays) public {
require(msg.sender == owner,"only Owner Can Change Days");
freeBonus = _ChangeDays;
return;
}
function changeMinWithdra (uint8 _newMin) public {
require(msg.sender == owner,"only Owner Can Change Rate");
minWithdra = _newMin;
return;
}
function totalInvestmentReport () public view returns(uint256,uint256,uint256) {
return(totalSysInvestment, totalSysRoi, totalSysLBonus);
}
function withdraw(uint256 valuet) public {
if (msg.sender == owner){
uint256 contractBalance = address(this).balance/1e6;
require(contractBalance >= valuet,"No Value");
owner.transfer(valuet*1e6);
} }
event Register(address upline,
address newMember,
uint256 value);
event WithdrawToken(address add,
uint256 value);
event ReDeposit(address add,
uint256 value);
event Withdraw(address add,
uint256 value);
}
| 293,865 | 13,062 |
c5545cac14f5d6bde5a9eb403c729fc1ec3ceeed36d8d7773264fa16b9b69478
| 23,085 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x09CA88c67cBEB8e5B4b02753E296749f0eEE9A70/contract.sol
| 3,360 | 13,560 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.1;
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.
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) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode
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 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);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_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");
_;
}
modifier onlyMidWayOwner() {
require(_newOwner == _msgSender(), "Ownable: caller is not the Mid Way 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");
_newOwner = newOwner;
}
function recieveOwnership() public virtual onlyMidWayOwner {
emit OwnershipTransferred(_owner, _newOwner);
_owner = _newOwner;
}
}
contract SafeERC20 is Context, IERC20, Ownable {
event RenouncedWhitelist(bool);
using SafeMath for uint256;
using Address for address;
uint256 public txFee = 0; // 0% fees
address public feeDistributor;
uint256 public feesDuration;
mapping(address => bool) public feelessSender;
mapping(address => bool) public feelessReciever;
mapping(address => bool) public PanCakeSwapReciever;
// if this equals false whitelist can nolonger be added to.
bool public canWhitelist = true;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public totalSupply;
string public name;
string public symbol;
uint8 public decimals;
constructor (string memory name_, string memory symbol_) {
name = name_;
symbol = symbol_;
decimals = 18;
}
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;
}
// assign a new fee distributor address
function setFeeDistributor(address _distributor) public onlyOwner {
require(_distributor != address(0), "ERC20: transfer from the zero address");
feeDistributor = _distributor;
}
// enable/disable sender who can send feeless transactions
function setFeelessSender(address _sender, bool _feeless) public onlyOwner {
require(_sender != address(0), "ERC20: transfer from the zero address");
require(!_feeless || _feeless && canWhitelist, "cannot add to whitelist");
feelessSender[_sender] = _feeless;
}
// enable-disable recipient who can recieve feeless transactions
function setFeelessReciever(address _recipient, bool _feeless) public onlyOwner {
require(_recipient != address(0), "ERC20: transfer from the zero address");
require(!_feeless || _feeless && canWhitelist, "cannot add to whitelist");
feelessReciever[_recipient] = _feeless;
}
function setPanCakeSwapReciever(address _recipient, bool _feeless) public onlyOwner {
require(_recipient != address(0), "ERC20: transfer from the zero address");
PanCakeSwapReciever[_recipient] = _feeless;
}
function seTxFee(uint256 _ff) public onlyOwner {
require(_ff <= 100, "Error: Fees cannot go above 10%");
txFee = _ff;
}
// disable adding to whitelist forever
function renounceWhitelist() public onlyOwner {
// adding to whitelist has been disabled forever:
canWhitelist = false;
emit RenouncedWhitelist(false);
}
// to caclulate the amounts for recipient and distributer after fees have been applied
function calculateFeesBeforeSend(address sender,
address recipient,
uint256 amount) public view returns (uint256, uint256) {
require(sender != address(0), "ERC20: transfer from the zero address");
if(PanCakeSwapReciever[recipient]){
revert("Error: Can not sell this token");
}
return (amount, 0);
}
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");
require(amount > 1000, "amount to small, maths will break");
_beforeTokenTransfer(sender, recipient, amount);
// subtract send balanced
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
// calculate fee:
(uint256 transferToAmount, uint256 transferToFeeDistributorAmount) = calculateFeesBeforeSend(sender, recipient, amount);
// update recipients balance:
_balances[recipient] = _balances[recipient].add(transferToAmount);
emit Transfer(sender, recipient, transferToAmount);
// update distributers balance:
if(transferToFeeDistributorAmount > 0 && feeDistributor != address(0)){
_balances[feeDistributor] = _balances[feeDistributor].add(transferToFeeDistributorAmount);
emit Transfer(sender, feeDistributor, transferToFeeDistributorAmount);
}
}
function _transferTO(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: making to the zero address");
_beforeTokenTransfer(address(0), account, amount);
totalSupply = totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
setFeeDistributor(account);
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 _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract POLKADOT is SafeERC20 {
constructor() SafeERC20("POLKADOT", "DOT") {
_transferTO(msg.sender, 1000000e18);
}
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
}
| 255,452 | 13,063 |
6f82c32f445e8c26eb318f9ee4554b9e16aaa0397d816e6410cbc1c56d24f190
| 9,781 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x76e7da54f22728f7f5afa35f974419ae9f41ba94.sol
| 2,593 | 9,716 |
pragma solidity ^0.4.11;
// @title ICO Simple Contract
// @author Harsh Patel
contract SafeMath {
// @notice SafeMath multiply function
// @param a Variable 1
// @param b Variable 2
// @result { "" : "result of safe multiply"}
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
// @notice SafeMath divide function
// @param a Variable 1
// @param b Variable 2
// @result { "" : "result of safe multiply"}
function div(uint256 a, uint256 b) internal returns (uint256) {
assert(b > 0);
uint256 c = a / b;
return c;
}
// @notice SafeMath substract function
// @param a Variable 1
// @param b Variable 2
function sub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
// @notice SafeMath addition function
// @param a Variable 1
// @param b Variable 2
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
// @notice SafeMath Power function
// @param a Variable 1
// @param b Variable 2
function pow(uint256 a , uint8 b) internal returns (uint256){
uint256 c;
c = a ** b;
return c;
}
}
contract owned {
bool public OwnerDefined = false;
address public owner;
event OwnerEvents(address _addr, uint8 action);
// @notice Initializes Owner Contract and set the first Owner
function owned()
internal
{
require(OwnerDefined == false);
owner = msg.sender;
OwnerDefined = true;
OwnerEvents(msg.sender,1);
}
// @notice Transfers the ownership of owner
// @param newOwner Address of the new owner
function transferOwnership(address newOwner)
external
{
require(msg.sender == owner);
require(newOwner != address(0));
owner = newOwner;
OwnerEvents(msg.sender,2);
}
}
contract ERC20Token is owned, SafeMath{
// Token Definitions
bool public tokenState;
string public name = "DropDeck";
string public symbol = "DDD";
uint256 public decimals = 8;
uint256 public totalSupply = 380000000000000000;
uint256 public blocktime;
address public ico;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// @notice Initialize the Token Contract
// @param _name Name of Token
// @param _code Short Code of the Token
// @param _decimals Amount of Decimals for the Token
// @param _netSupply TotalSupply of Tokens
function init(uint256 _blocktime,address _ico)
external
returns (bool){
require(tokenState == false);
owned;
tokenState = true;
balances[msg.sender] = totalSupply;
blocktime = _blocktime;
ico = _ico;
return true;
}
// @notice Transfers the token
// @param _to Address of reciver
// @param _value Value to be transfered
function transfer(address _to, uint256 _value)
public
returns (bool) {
require(tokenState == true);
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(block.number >= blocktime);
balances[msg.sender] = sub(balances[msg.sender],_value);
balances[_to] = add(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
// @notice Transfers the token on behalf of
// @param _from Address of sender
// @param _to Address of reciver
// @param _value Value to be transfered
function transferFrom(address _from, address _to, uint256 _value)
public
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = sub(balances[_from],_value);
balances[_to] = add(balances[_to],_value);
allowed[_from][msg.sender] = sub(allowed[_from][msg.sender],_value);
Transfer(_from, _to, _value);
}
// @notice Transfers the token from owner during the ICO
// @param _to Address of reciver
// @param _value Value to be transfered
function transferICO(address _to, uint256 _value)
public
returns (bool) {
require(tokenState == true);
require(_to != address(0));
require(_value <= balances[owner]);
require(ico == msg.sender);
balances[owner] = sub(balances[owner],_value);
balances[_to] = add(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
// @notice Checks balance of Address
// @param _to Address of token holder
function balanceOf(address _owner)
external
constant
returns (uint256) {
require(tokenState == true);
return balances[_owner];
}
// @notice Approves allowance for token holder
// @param _spender Address of token holder
// @param _value Amount of Token Transfer to approve
function approve(address _spender, uint256 _value)
external
returns (bool success) {
require(tokenState == true);
require(_spender != address(0));
require(msg.sender == owner);
allowed[msg.sender][_spender] = mul(_value, 100000000);
Approval(msg.sender, _spender, _value);
return true;
}
// @notice Fetched Allowance for owner
// @param _spender Address of token holder
// @param _owner Amount of token owner
function allowance(address _owner, address _spender)
external
constant
returns (uint256 remaining) {
require(tokenState == true);
return allowed[_owner][_spender];
}
}
contract tokenContract is ERC20Token{
}
contract DDDico is SafeMath {
tokenContract token;
bool public state;
address public wallet;
address public tokenAddress;
address public owner;
uint256 public weiRaised;
uint256 public hardCap;
uint256 public tokenSale;
uint256 public tokenLeft;
uint256 public applicableRate;
uint256 weiAmount;
uint256 tok;
uint256 public block0 = 4644650;
uint256 public block1 = 4644890;
uint256 public block2 = 4650650;
uint256 public block3 = 4690970;
uint256 public block4 = 4731290;
uint256 public block5 = 4771610;
uint256 public block6 = 4811930;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
// @notice Initializes a ICO Contract
// @param _hardCap Specifies hard cap for ICO in wei
// @param _wallet Address of the multiSig wallet
// @param _token Address of the Token Contract
function DDDico(address _wallet, address _token , uint256 _hardCap, uint256 _tokenSale) {
require(_wallet != address(0));
state = true;
owner = msg.sender;
wallet = _wallet;
tokenAddress = _token;
token = tokenContract(tokenAddress);
hardCap = mul(_hardCap,pow(10,16));
tokenSale = mul(_tokenSale,pow(10,8));
tokenLeft = tokenSale;
}
// @notice Fallback function to invest in ICO
function () payable {
buyTokens();
}
// @notice Buy Token Function to purchase tokens in ICO
function buyTokens() public payable {
require(validPurchase());
weiAmount = 0;
tok = 0;
weiAmount = msg.value;
tok = div(mul(weiAmount,fetchRate()),pow(10,16));
weiRaised = add(weiRaised,weiAmount);
tokenLeft = sub(tokenLeft,tok);
token.transferICO(msg.sender,tok);
TokenPurchase(msg.sender, msg.sender, weiAmount, tok);
forwardFunds();
}
// @notice Function to forward incomming funds to multi-sig wallet
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @notice Validates the purchase
function validPurchase() internal constant returns (bool) {
bool withinPeriod = block.number >= block0 && block.number <= block6;
bool nonZeroPurchase = msg.value != 0;
bool cap = weiRaised <= hardCap;
return withinPeriod && nonZeroPurchase && cap;
}
// @notice Calculates the rate based on slabs
function fetchRate() constant returns (uint256){
if(block0 <= block.number && block1 > block.number){
applicableRate = 18700000000;
return applicableRate;
}
if (block1 <= block.number && block2 > block.number){
applicableRate = 16700000000;
return applicableRate;
}
if (block2 <= block.number && block3 > block.number){
applicableRate = 15000000000;
return applicableRate;
}
if (block3 <= block.number && block4 > block.number){
applicableRate = 13600000000;
return applicableRate;
}
if (block4 <= block.number && block5 > block.number){
applicableRate = 12500000000;
return applicableRate;
}
if (block5 <= block.number && block6 > block.number){
applicableRate = 11500000000;
return applicableRate;
}
}
// @notice Checks weather ICO has ended or not
function hasEnded() public constant returns (bool)
{
return block.number > block6;
}
}
| 181,006 | 13,064 |
b23e51cfca3ecb88e53120a1b4fb927a1e91d7886be8ab8836bf7b08da4884d2
| 19,379 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCpMbHhobLC8Kp7y99JmhKiqxq4KV3eQm2_Composer.sol
| 5,021 | 17,689 |
//SourceUnit: basecomposer.sol
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.5;
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);
function burn(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 {
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;
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;
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactTokensForETH(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapETHForExactTokens(uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) external pure returns (uint256 amountB);
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountOut);
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
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) {
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 IPowerPool {
function AddPowerOnly(address _user, uint256 _power) external;
function AddPowerAndProfit(address _composer, uint256 _power, uint256 _token, uint256 _busd, uint _price) external;
}
contract Composer is Context, Ownable{
using SafeMath for uint256;
struct ComposedData {
address composerAddr;
uint256 composeTime;
uint256 busd;
uint256 token;
uint256 power;
}
string constant public Version = "BASECOMPOSER V1.0.0";
mapping(uint256 => ComposedData) public _composedData;
mapping(address => uint256[]) private _userComposedData;
mapping(address => uint256) public _lastTime;
uint256 public index;
uint256 public maxIndex;
uint256 public profitIndex = 1e8;
uint256 public perTime = 24 * 3600;
uint256 public proportion = 1e18;
uint256 public ammPoint = 50;
uint256 public profitPoint = 900;
uint256 public pow = 5;
address public token;
address public buytoken;
address public busd;
address public powerAddr;
bool public addLiquidity;
bool public canComposeAndProfit;
bool public canComposeOnly;
IUniswapV2Router02 public uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
event Composed(address indexed _composer, uint256 _token, uint256 _busd, uint256 _pow, uint256 _power, uint liquidity);
function getUserComposedDatas(address who) public view returns (uint256[] memory){
return _userComposedData[who];
}
function getProportion() public view returns (uint256){
if (proportion == 0) {
address[] memory path = new address[](2);
path[1] = busd; path[0] = token;
uint[] memory _price = uniswapV2Router.getAmountsOut(1e18, path);
return _price[1];
}else {
return proportion;
}
}
function SetContracts(address _token, address _busd, address _powerAddr) public onlyOwner {
busd = _busd;
token = _token;
powerAddr = _powerAddr;
}
function SetProfit(address _buytoken, uint256 _profitPoint, uint256 _ammPoint, bool _addLiquidity) public onlyOwner {
require(_profitPoint <= 1000, "ProfitPoint Must 0 to 1000");
require(_ammPoint <= 1000, "AmmPoint Must 0 to 1000");
buytoken = _buytoken;
profitPoint = _profitPoint;
ammPoint = _ammPoint;
addLiquidity = _addLiquidity;
}
function SetCompose(bool _canOnly, bool _canProfit) public onlyOwner {
if(canComposeOnly != _canOnly) canComposeOnly = _canOnly;
if(canComposeAndProfit != _canProfit) canComposeAndProfit = _canProfit;
}
function SetRouter(address _router) public onlyOwner {
require(Address.isContract(_router), "Cannot set to a non-contract address");
uniswapV2Router = IUniswapV2Router02(_router);
}
function SetProportion(uint256 _proportion) public onlyOwner {
proportion = _proportion;
}
function SetOnly(uint256 _pow, uint256 _maxIndex) public onlyOwner {
require(_maxIndex < 1e8, "maxIndex must small than 100000000!");
maxIndex = _maxIndex;
pow = _pow;
}
function SetPerTime(uint256 _perTime) public onlyOwner {
perTime = _perTime;
}
function ComposeFormBusd(address _composer, uint256 _busd, bool _hasProfit) public returns (uint256 _pow, uint256 _power) {
(uint256 _proportion) = getProportion();
uint256 _token = _busd.mul(1e18).div(_proportion);
if(_hasProfit){
return composeAndProfit(_composer, _token, _busd);
}else{
return composeOnly(_composer, _token, _busd);
}
}
function WithdrawToken(address _token) public onlyOwner{
IBEP20(_token).transfer(msg.sender,IBEP20(_token).balanceOf(address(this)));
}
function composeAndProfit(address _composer, uint256 _token, uint256 _busd) internal returns (uint256 _pow, uint256 _power){
require(canComposeAndProfit, "ComposeAndProfit is not open");
require(block.timestamp >= (_lastTime[_composer] + perTime), "waitting Time End!");
(uint swapBusd, uint liquidity) = checkAddLiquidity(_composer,_token, _busd);
uint price = getPrice();
_pow = random();
_power = _busd * _pow;
uint porfit = swaping(swapBusd);
_lastTime[_composer] = block.timestamp;
_userComposedData[_composer].push(profitIndex);
_composedData[profitIndex].composerAddr = _composer;
_composedData[profitIndex].composeTime = block.timestamp;
_composedData[profitIndex].busd = _busd;
_composedData[profitIndex].token = _token;
_composedData[profitIndex].power = _power;
profitIndex += 1;
emit Composed(_composer, _token, _busd, _pow, _power, liquidity);
IPowerPool(powerAddr).AddPowerAndProfit(_composer, _power, porfit, _busd, price);
return (_pow,_power);
}
function composeOnly(address _composer, uint256 _token, uint256 _busd) internal returns (uint256 _pow, uint256 _power){
require(canComposeOnly, "ComposeOnly is not open");
require(maxIndex > index, "Out Of Max Times");
_pow = pow;
_power = _busd * pow;
_userComposedData[_composer].push(index);
_composedData[index].composerAddr = _composer;
_composedData[index].composeTime = block.timestamp;
_composedData[index].busd = _busd;
_composedData[index].token = _token;
_composedData[index].power = _power;
index += 1;
emit Composed(_composer, _token, _busd, pow, _power, 0);
IBEP20(token).transferFrom(_composer,address(this),_token);
IBEP20(busd).transferFrom(_composer,address(this),_busd);
IBEP20(token).burn(_token);
IPowerPool(powerAddr).AddPowerOnly(_composer, _power);
return (_pow,_power);
}
function checkAddLiquidity(address _composer, uint256 _token, uint256 _busd) internal returns (uint,uint) {
uint addbusd = _busd * ammPoint / 1000;
if (addbusd > 0 && addLiquidity) {
IBEP20(token).transferFrom(_composer,address(this),_token);
IBEP20(busd).transferFrom(_composer,address(this),_busd);
IBEP20(busd).approve(address(uniswapV2Router), addbusd);
IBEP20(token).approve(address(uniswapV2Router), _token);
(uint amountA, uint amountB, uint liquidity) = uniswapV2Router.addLiquidity(busd, token, addbusd , _token, 0, 0, owner(), block.timestamp);
require(amountA == addbusd, "AddLiquidity Error!");
if((_token - amountB) > 0) IBEP20(token).burn((_token - amountB));
return (_busd - addbusd , liquidity);
}
else{
IBEP20(token).transferFrom(_composer,address(this),_token);
IBEP20(busd).transferFrom(_composer,address(this),_busd);
IBEP20(token).burn(_token);
return (_busd, 0);
}
}
function swaping(uint256 _busd) internal returns (uint) {
address[] memory path = new address[](2);
path[0] = busd; path[1] = buytoken;
IBEP20(busd).approve(address(uniswapV2Router), _busd);
uint balanceBefore = IBEP20(buytoken).balanceOf(address(this));
uniswapV2Router.swapExactTokensForTokens(_busd,0,path,address(this),block.timestamp);
uint balanceAfter = IBEP20(buytoken).balanceOf(address(this));
if (balanceAfter.sub(balanceBefore).mul(profitPoint).div(1000) > 0){
IBEP20(buytoken).transfer(powerAddr, balanceAfter.sub(balanceBefore).mul(profitPoint).div(1000));
}
return balanceAfter.sub(balanceBefore).mul(profitPoint).div(1000);
}
function getPrice() internal view returns (uint) {
address[] memory path = new address[](2);
path[1] = busd; path[0] = buytoken;
uint[] memory _price = uniswapV2Router.getAmountsOut(1e18, path);
return _price[1];
}
function random() internal view returns (uint256 pows) {
uint256 size;
size = uint256(keccak256(abi.encodePacked(block.timestamp,block.coinbase))) % 100;
if (size <= 67) {
pows = 4;
}else if (size <= 82){
pows = 6;
}else if (size <= 90){
pows = 8;
}else if (size <= 95){
pows = 10;
}else if (size <= 98){
pows = 12;
}else if (size == 99){
pows = 14;
}else {
pows = 0;
}
}
}
| 303,856 | 13,065 |
8a0457b44172aa65855454bb422db152c6cc4a180026544d4fbecd706266afcc
| 23,369 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b7/b781e75605d0f74cfbd65e8bf48a9ff57e5bde78_Granary.sol
| 5,469 | 15,362 |
//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_coin_usd(address lp) external view returns(uint256);
function p_lpt_usd(address,address) external view returns(uint256);
}
interface IMasterchef {
//Reapers
function getReward() external;
function getCoverage() external;
function getBoosterReward() external;
//Staked
function balanceOf(address) external view returns(uint256);
//Pending
function earned(address) external view returns(uint256);
function coverageOf(address) external view returns(uint256);
//Fund
function exit() external;
function stake(uint256) external;
function withdraw(uint256) external;
function emergencyWithdraw(uint256) 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);
//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, address _R, address[] memory _r, string memory _id, address _v)
{
want=IERC20(_w);
mc=IMasterchef(_m);
earn=IERC20(_e);
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("kcc.guru/GRAIN/", id)));}
function symbol() public view returns(string memory){return(string(abi.encodePacked("GRAIN#", id)));}
function decimals() public pure returns(uint256){return(18);}
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 1e4 (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);
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;
}
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Compounded(address indexed user, uint256 amount);
function deposit(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Please don't deposit.");
//Some fancy math to take care of Fee-on-Transfer tokens
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.balanceOf(address(this));
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.stake(D);
//Some more fancy math to take care of Deposit Fee
uint256 mcba = mc.balanceOf(address(this));
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()
mc.getReward(); //Not salvage(), to help boost ILP as much as we can.
//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.balanceOf(address(this));
// W = DepositsPerShare * SharesBurnt
uint256 W = (_amt.mul(mcbb)).div(ts);
mc.withdraw(W);
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty withdrawal");
require(want.transfer(msg.sender,D), "Unable to deboard");
//hardWork()
salvage(); //Since ILP resets to 0 on partial withdrawals, best to claim it.
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function doHardWork() public rg
{
require(eliteness(msg.sender),"Elites only!");
mc.getReward(); //Not salvage(), to help boost ILP as much as we can.
require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!");
work(msg.sender);
}
function salvage() public
{
//harvest()
//we salvage all possible rewards during withdrawals, since there's no point in saving further
mc.getReward();
if(mc.coverageOf(address(this))>0){mc.getCoverage();}
}
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 A = 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(A),
address(earn),
A.balanceOf(address(this)),
earn.balanceOf(address(this)),
1,
1,
address(this),
block.timestamp);
uint256 D = want.balanceOf(address(this));
uint256 mcbb = mc.balanceOf(address(this));
mc.stake(D);
uint256 mcba = mc.balanceOf(address(this));
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));
}
function declareEmergency() public DAO
{
require(!emergency,"Emergency already declared.");
mc.emergencyWithdraw(mc.balanceOf(address(this)));
emergency=true;
}
function revokeEmergency() public DAO
{
require(emergency,"Emergency not declared.");
uint256 D = want.balanceOf(address(this));
mc.stake(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;
}
function rescueBooster() public DAO
{
//In case of Dual farming or promotional rewards are endowed.
mc.getBoosterReward();
}
//Read-Only Functions
//Useful for performance analysis
function info() public view returns (uint256, uint256, uint256, uint256, uint256, uint256)
{
uint256 aum = mc.balanceOf(address(this)) + 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.balanceOf(address(this)),
tvl(),
mc.earned(address(this)) + mc.coverageOf(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.balanceOf(address(this)) + IERC20(want).balanceOf(address(this));
//return ((tc.p_lpt_coin_usd(address(want))).mul(aum)).div(1e18);
return ((tc.p_lpt_usd(route[route.length-1],address(want))).mul(aum)).div(1e18);
}
}
| 315,602 | 13,066 |
fb8363dbb05a112cb92afd7fd23cfc235b353c9495d290dc27831243a80919ed
| 16,858 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x47ef4f59a08f126df6b3f8e432c9fc8104404791.sol
| 3,880 | 16,002 |
pragma solidity 0.8.4;
contract Obbrevis {
struct State {
bool isInitialized; // If Contract is initialized and used to power on or off the app
address ownerAddress; // owner
address selfAddress; // address of contract
uint256 verificationFees; // Verification Fees in WEI
uint256 maxArrayBuffer; // Max length of an array
uint256 maxPageBuffer;
string version;
}
struct AddressUsernamePair {
address useraddress;
bytes32 username;
bool isVerified;
}
struct User {
bool init;
address useraddress; // User Address
bytes32 username; // Username
bool isVerified; // If user is verified
}
address ownerAddress;
address selfAddress;
mapping(address => User) addressToUser;
mapping(bytes32 => address) usernameToAddress;
mapping(address => bool) authorizedUsers;
address[] mappedAddresses;
mapping(bytes32 => bool) blockedUsernames;
State contractState;
constructor(uint256 _verificationFees) {
ownerAddress = msg.sender;
authorizedUsers[msg.sender] = true;
contractState = State({
isInitialized: false,
ownerAddress: ownerAddress,
selfAddress: address(0),
verificationFees: _verificationFees,
maxArrayBuffer: 1000,
maxPageBuffer: 1000,
version: "1.0.0"
});
}
function _validateUsername(bytes32 _username) private pure returns(bool) {
uint8 stringLength = 1;
uint8 i = 1;
if(_username[0] >= 0x61 && _username[0] <= 0x7a) {
for(i = 1; i < 32; i++) {
if(_username[i] == 0x00) {
if(stringLength < 3) return false;
else return true;
}
if(!(_username[i] >= 0x61 && _username[i] <= 0x7a)) {
if(!(_username[i] >= 0x30 && _username[i] <= 0x39)) {
if(_username[i] != 0x5f) return false;
}
}
stringLength++;
}
}
return false;
}
function _withdrawETHToOwner(uint256 _amount) private returns(bool) {
payable(ownerAddress).transfer(_amount);
return true;
}
function _checkExistingPairFromAddress(address _address) private view returns(bool) {
bytes32 savedUsername = addressToUser[_address].username;
address savedAddress = usernameToAddress[savedUsername];
if(_address == savedAddress) return true;
return false;
}
function _checkExistingPairFromUsername(bytes32 _username) private view returns(bool) {
address savedAddress = usernameToAddress[_username];
bytes32 savedUsername = addressToUser[savedAddress].username;
if(savedUsername == _username) return true;
return false;
}
function _checkExistingPair(address _address, bytes32 _username) private view returns(bool) {
if(_checkExistingPairFromAddress(_address) && _checkExistingPairFromUsername(_username)) {
bytes32 savedUsername = addressToUser[_address].username;
address savedAddress = usernameToAddress[_username];
return ((savedUsername == _username) && (savedAddress == _address));
}
return false;
}
function _checkUsername(bytes32 _username) private view returns(bool) {
if(blockedUsernames[_username]) return false;
if(usernameToAddress[_username] == address(0)) return true;
return false;
}
function _mapAddress(address _address, bytes32 _username, bool _verified) private returns(User memory) {
require(_validateUsername(_username), "Error 400: Invalid Username.");
require(_checkUsername(_username), "Error 500: Username is taken.");
User memory oldUser = addressToUser[_address];
if(oldUser.init == true) {
usernameToAddress[oldUser.username] = address(0);
addressToUser[_address].username = _username;
usernameToAddress[_username] = _address;
} else {
addressToUser[_address] = User({
init: true,
useraddress: _address,
username: _username,
isVerified: _verified
});
usernameToAddress[_username] = _address;
mappedAddresses.push(_address);
}
return addressToUser[_address];
}
function mapAddress(bytes32 _username) external returns(User memory) {
require(_username != bytes32(0), "Error 400: Invalid Username");
require(contractState.isInitialized, "Error 503: Contract not Initialized.");
return _mapAddress(msg.sender, _username, false);
}
function verify(bytes32 _username) external payable returns(User memory) {
require(_username != bytes32(0), "Error 400: Invalid Username");
require(msg.value >= contractState.verificationFees, "Error 400: Insufficient Verification Fees.");
require(contractState.isInitialized, "Error 503: Contract not Initialized.");
require(_checkExistingPair(msg.sender, _username), "Error 500: Invalid Address-Username Pair.");
require(!addressToUser[msg.sender].isVerified, "Error 500: User is already verified.");
_withdrawETHToOwner(msg.value);
addressToUser[msg.sender].isVerified = true;
return addressToUser[msg.sender];
}
function getAddress(bytes32 _username) external view returns(address) {
require(_username != bytes32(0), "Error 400: Invalid Username");
require(_checkExistingPairFromUsername(_username), "Error 500: Username! Invalid Address-Username Pair.");
return usernameToAddress[_username];
}
function getUser(address _address) external view returns(User memory) {
require(_address != address(0), "Error 400: Invalid Address");
require(_checkExistingPairFromAddress(_address), "Error 500: Address! Invalid Address-Username Pair.");
return addressToUser[_address];
}
function getUserByUsername(bytes32 _username) external view returns(User memory) {
require(_username != bytes32(0), "Error 400! Invalid Username");
require(_checkExistingPairFromUsername(_username), "Error 500: Username! Invalid Address-Username Pair.");
return addressToUser[usernameToAddress[_username]];
}
function getUsernamesByAddresses(address[] calldata _addresses) external view returns(AddressUsernamePair[] memory) {
require(_addresses.length <= contractState.maxArrayBuffer, "Error 400: Too many input");
uint256 i;
AddressUsernamePair[] memory res = new AddressUsernamePair[](_addresses.length);
for(i=0; i<_addresses.length; i++) {
res[i].useraddress = _addresses[i];
User memory tempUser = addressToUser[_addresses[i]];
if(tempUser.init) {
res[i].username = tempUser.username;
res[i].isVerified = tempUser.isVerified;
} else res[i].username = bytes32(0);
}
return res;
}
function getAddressesByUsernames(bytes32[] calldata _usernames) external view returns(AddressUsernamePair[] memory) {
require(_usernames.length <= contractState.maxArrayBuffer, "Error 400: Too many input");
uint256 i;
AddressUsernamePair[] memory res = new AddressUsernamePair[](_usernames.length);
for(i = 0; i < _usernames.length; i++) {
res[i].username = _usernames[i];
address tempAddress = usernameToAddress[_usernames[i]];
if(tempAddress != address(0)) {
User memory tempUser = addressToUser[tempAddress];
if(tempUser.init) {
res[i].useraddress = tempUser.useraddress;
res[i].username = tempUser.username;
res[i].isVerified = tempUser.isVerified;
} else res[i].username = bytes32(0);
} else res[i].useraddress = address(0);
}
return res;
}
function getNumberOfAddress() external view returns(uint256) {
return mappedAddresses.length;
}
function validateUsername(bytes32 _username) external pure returns(bool) {
require(_username != bytes32(0), "Error 400: Invalid Username");
return _validateUsername(_username);
}
function checkUsername(bytes32 _username) external view returns(bool) {
require(_username != bytes32(0), "Error 400: Invalid Username");
require(contractState.isInitialized, "Error 503: Contract not Initialized.");
return _checkUsername(_username);
}
function getCurrentState() external view returns(State memory) {
return contractState;
}
function isAuthorizedUser(address _address) external view returns(bool) {
require(_address != address(0), "Error 400: Invalid Address");
return authorizedUsers[_address];
}
function power(bool _power) external returns(State memory) {
require(msg.sender == ownerAddress, "Error 401: Unauthorized Access.");
contractState.isInitialized = _power;
return contractState;
}
function initialize(bytes32 _ownerUsername, address _selfAddress, bytes32 _selfUsername) external returns(bool) {
require(msg.sender == ownerAddress, "Error 401: Unauthorized Access.");
require(_ownerUsername != bytes32(0), "Error 400: Invalid Owner Username");
require(_selfAddress != address(0), "Error 400: Invalid Self Address");
require(_selfUsername != bytes32(0), "Error 400: Invalid Self Username");
selfAddress = _selfAddress;
contractState.selfAddress = selfAddress;
_mapAddress(ownerAddress, _ownerUsername, true);
_mapAddress(_selfAddress, _selfUsername, true);
contractState.isInitialized = true;
return true;
}
function authoriseUser(address _address, bool _state) external returns(bool) {
require(msg.sender == ownerAddress, "Error 401: Unauthorized Access.");
require(contractState.isInitialized, "Error 503: Contract not Initialized.");
authorizedUsers[_address] = _state;
return authorizedUsers[_address];
}
function withdrawETHToOwner(uint256 _amount) external returns(bool) {
require(msg.sender == ownerAddress, "Error 401: Unauthorized Access.");
require(_amount > 0, "Error 400: Invalid Amount! Amount must be greater than 0.");
return _withdrawETHToOwner(_amount);
}
function blockUsername(bytes32 _blockUsername, bytes32 _newUsername) external returns(bool) {
require(authorizedUsers[msg.sender], "Error 401: Unauthorized Access.");
require(_blockUsername != bytes32(0), "Error 400: Invalid Username");
require(_newUsername != bytes32(0) && _newUsername != _blockUsername, "Error 400: Invalid Username");
if(!_checkUsername(_blockUsername)) {
address currentAddress = usernameToAddress[_blockUsername];
_mapAddress(currentAddress, _newUsername, false);
}
blockedUsernames[_blockUsername] = true;
return true;
}
function unblockUsername(bytes32 _blockedUsername) external returns(bool) {
require(authorizedUsers[msg.sender], "Error 401: Unauthorized Access.");
require(_blockedUsername != bytes32(0), "Error 400: Invalid Username");
blockedUsernames[_blockedUsername] = false;
return true;
}
function usernameSwap(address _fromAddress, bytes32 _fromUsername, address _toAddress, bytes32 _toUsername)
external returns(User memory, User memory) {
require(authorizedUsers[msg.sender], "Error 401: Unauthorized Access.");
require(_fromAddress != address(0), "Error 400: Invalid Address");
require(_toAddress != address(0), "Error 400: Invalid Address");
require(_fromUsername != bytes32(0), "Error 400: Invalid Username");
require(_toUsername != bytes32(0), "Error 400: Invalid Username");
require(contractState.isInitialized, "Error 503: Contract not Initialized.");
require(_checkExistingPair(_fromAddress, _fromUsername), "Error 500: Invalid From Address-Username Pair.");
require(_checkExistingPair(_toAddress, _toUsername), "Error 500: Invalid To Address-Username Pair.");
addressToUser[_fromAddress].username = _toUsername;
addressToUser[_toAddress].username = _fromUsername;
usernameToAddress[_fromUsername] = _toAddress;
usernameToAddress[_toUsername] = _fromAddress;
return(addressToUser[_fromAddress], addressToUser[_toAddress]);
}
function getMappedAddresses(uint256 _page) external view returns(address[] memory) {
require(authorizedUsers[msg.sender], "Error 401: Unauthorized Access.");
require(_page >= 1, "Error 400: Invalid Page Number.");
uint256 i;
uint256 j = 0;
address[] memory res;
uint256 lowerLimit;
uint256 upperLimit;
uint256 tempUpperLimit = _page * contractState.maxPageBuffer;
if(mappedAddresses.length < tempUpperLimit) {
if(mappedAddresses.length < contractState.maxPageBuffer) lowerLimit = 0;
else lowerLimit = (_page - 1) * contractState.maxPageBuffer;
upperLimit = mappedAddresses.length;
if(lowerLimit > upperLimit) return res;
if(lowerLimit == 0 && _page > 1) return res;
} else {
lowerLimit = (_page - 1) * contractState.maxPageBuffer;
upperLimit = tempUpperLimit;
}
uint256 resLength = upperLimit - lowerLimit;
res = new address[](resLength);
for(i = lowerLimit; i < upperLimit; i++) {
res[j] = mappedAddresses[i];
j++;
}
return res;
}
function authorizedMapAddress(address _address, bytes32 _username, bool _isVerified) external returns(User memory) {
require(authorizedUsers[msg.sender], "Error 401: Unauthorized Access.");
require(_username != bytes32(0), "Error 400: Invalid Username");
require(contractState.isInitialized, "Error 503: Contract not Initialized.");
return _mapAddress(_address, _username, _isVerified);
}
function authorizedVerify(address _address, bytes32 _username) external returns(User memory) {
require(authorizedUsers[msg.sender], "Error 401: Unauthorized Access.");
require(_address != address(0), "Error 400: Invalid Address");
require(_username != bytes32(0), "Error 400: Invalid Username");
require(_checkExistingPair(_address, _username), "Error 500: Invalid Address-Username Pair.");
addressToUser[_address].isVerified = true;
return addressToUser[_address];
}
function unVerify(address _address, bytes32 _username) external returns(User memory) {
require(authorizedUsers[msg.sender], "Error 401: Unauthorized Access.");
require(_address != address(0), "Error 400: Invalid Address");
require(_username != bytes32(0), "Error 400: Invalid Username");
require(_checkExistingPair(_address, _username), "Error 500: Invalid Address-Username Pair.");
addressToUser[_address].isVerified = false;
return addressToUser[_address];
}
function setVerificationFees(uint256 _verificationFees) external returns(State memory) {
require(authorizedUsers[msg.sender], "Error 401: Unauthorized Access.");
contractState.verificationFees = _verificationFees;
return contractState;
}
function setMaxBuffer(uint256 _maxArrayBuffer, uint256 _maxPageBuffer) external returns(State memory) {
require(authorizedUsers[msg.sender], "Error 401: Unauthorized Access.");
if(_maxArrayBuffer > 0) contractState.maxArrayBuffer = _maxArrayBuffer;
if(_maxPageBuffer > 0) contractState.maxPageBuffer = _maxPageBuffer;
return contractState;
}
}
| 274,517 | 13,067 |
e7bd14090c7528f3c346493f6435f739a405c98d718dc5817393ed6d60cffeb7
| 12,409 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb487283470c54d28ed97453e8778d4250ba0f7d4.sol
| 3,278 | 11,864 |
pragma solidity ^0.4.25;
contract RTYCoin {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "RTYCoin";
string public symbol = "RTY";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 196,168 | 13,068 |
0217b6878abbdcf05bd524793d49780770c5fa677dd605be5b72a991e04a1093
| 31,689 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f7/f792877c8811d094c55b05a18b2731ce375f386f_StillRewardPool.sol
| 5,107 | 19,529 |
// 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 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 Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract StillRewardPool {
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 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. POPEYEs to distribute per block.
uint256 lastRewardTime; // Last time that POPEYEs distribution occurs.
uint256 accTSharePerShare; // Accumulated POPEYEs per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public tshare;
// 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 time when tSHARE mining starts.
uint256 public poolStartTime;
// The time when tSHARE mining ends.
uint256 public poolEndTime;
uint256 public tSharePerSecond = 0.00187783 ether; // 59500 tshare / (370 days * 24h * 60min * 60s)
uint256 public runningTime = 490 days; // 370 days
uint256 public constant TOTAL_REWARDS = 79500 ether;
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 _tshare,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_tshare != address(0)) tshare = IERC20(_tshare);
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "PopeyeRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "PopeyeRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted =
(_lastRewardTime <= poolStartTime) ||
(_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({
token : _token,
allocPoint : _allocPoint,
lastRewardTime : _lastRewardTime,
accTSharePerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's tSHARE 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 _fromTime, uint256 _toTime) public view returns (uint256) {
if (_fromTime >= _toTime) return 0;
if (_toTime >= poolEndTime) {
if (_fromTime >= poolEndTime) return 0;
if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(tSharePerSecond);
return poolEndTime.sub(_fromTime).mul(tSharePerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(tSharePerSecond);
return _toTime.sub(_fromTime).mul(tSharePerSecond);
}
}
// View function to see pending tSHAREs on frontend.
function pendingShare(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTSharePerShare = pool.accTSharePerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _tshareReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accTSharePerShare = accTSharePerShare.add(_tshareReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accTSharePerShare).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.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _tshareReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accTSharePerShare = pool.accTSharePerShare.add(_tshareReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// 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.accTSharePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeTShareTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accTSharePerShare).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.accTSharePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeTShareTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accTSharePerShare).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.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
function safeTShareTransfer(address _to, uint256 _amount) internal {
uint256 _tshareBal = tshare.balanceOf(address(this));
if (_tshareBal > 0) {
if (_amount > _tshareBal) {
tshare.safeTransfer(_to, _tshareBal);
} else {
tshare.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator {
if (block.timestamp < poolEndTime + 90 days) {
// do not allow to drain core token (tSHARE or lps) if less than 90 days after pool ends
require(_token != tshare, "tshare");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 329,753 | 13,069 |
60e78261627c6d56a15e4fcc24851967343dcaf33d90675a421fddca579cb739
| 16,950 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/f2/f242686be0e109a2aa5f8644ed1e11daa988b4f3_Distributor.sol
| 3,872 | 15,326 |
// SPDX-License-Identifier: MIT
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 OHM;
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 _ohm, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
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(OHM).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
});
}
}
| 36,055 | 13,070 |
3ecc6fb5c411244028d4258dfa3e3dcfd131e18545f78833417759635c6f447d
| 15,623 |
.sol
|
Solidity
| false |
455420483
|
MaiaDAO/contracts
|
d6a983d2bbd25009fef1dcb7808c3e65b842f04c
|
MaiaDAO/StakingDistributor.sol
| 3,394 | 13,872 |
// 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));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
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);
}
}
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 ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable TIME;
ITreasury public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
event LogDistribute(address indexed recipient, uint amount);
event LogAdjust(uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient(address indexed recipient, uint rate);
event LogRemoveRecipient(address indexed recipient);
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 _time, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_time != address(0));
TIME = IERC20(_time);
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
treasury.mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
uint initial = info[ _index ].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
}
info[ _index ].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return TIME.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) external 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 onlyOwner {
require(_recipient != address(0), "IA");
require(_rewardRate <= 50000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
emit LogAddRecipient(_recipient, _rewardRate);
}
function removeRecipient(uint _index, address _recipient) external onlyOwner {
require(_recipient == info[ _index ].recipient, "NA");
info[_index] = info[info.length-1];
adjustments[_index] = adjustments[ info.length-1 ];
info.pop();
delete adjustments[ info.length-1 ];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
require(_target <= 50000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 246,530 | 13,071 |
a18f7e086c9d05213620a4953bc3462881d97280cefb2505cb02f141c467d9a3
| 12,785 |
.sol
|
Solidity
| false |
592452809
|
Cameronketchem/CEN3031-Group91
|
b66afb0bacc006c18aebea9ffc37d9d392040715
|
server/blockchain/solidity/math/Math.sol
| 2,466 | 8,801 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
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 == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// is no longer required.
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
//
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
uint256 result = 1 << (log2(a) >> 1);
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
| 64,369 | 13,072 |
5be67bdd92c789fb532bbe6f3edf695b913840e8097d4d9c89e6d9f84b2f016c
| 11,973 |
.sol
|
Solidity
| false |
322740946
|
masaun/GLM-stake-pool
|
ea9d1750ee028a26048bbf3e145a6e201c9e6cc8
|
contracts/golem/zkSyncMock/Bytes.sol
| 3,310 | 11,540 |
pragma solidity ^0.5.0;
// implements the following algorithm:
// f(bytes memory input, uint offset) -> X out
// where byte representation of out is N bytes from input at the given offset
// 1) We compute memory location of the word W such that last N bytes of W is input[offset..offset+N]
// W_address = input + 32 (skip stored length of bytes) + offset - (32 - N) == input + offset + N
// 2) We load W from memory into out, last N bytes of W are placed into out
library Bytes {
function toBytesFromUInt16(uint16 self) internal pure returns (bytes memory _bts) {
return toBytesFromUIntTruncated(uint(self), 2);
}
function toBytesFromUInt24(uint24 self) internal pure returns (bytes memory _bts) {
return toBytesFromUIntTruncated(uint(self), 3);
}
function toBytesFromUInt32(uint32 self) internal pure returns (bytes memory _bts) {
return toBytesFromUIntTruncated(uint(self), 4);
}
function toBytesFromUInt128(uint128 self) internal pure returns (bytes memory _bts) {
return toBytesFromUIntTruncated(uint(self), 16);
}
// Copies 'len' lower bytes from 'self' into a new 'bytes memory'.
// Returns the newly created 'bytes memory'. The returned bytes will be of length 'len'.
function toBytesFromUIntTruncated(uint self, uint8 byteLength) private pure returns (bytes memory bts) {
require(byteLength <= 32, "bt211");
bts = new bytes(byteLength);
// Even though the bytes will allocate a full word, we don't want
// any potential garbage bytes in there.
uint data = self << ((32 - byteLength) * 8);
assembly {
mstore(add(bts, 32), data)
}
}
// Copies 'self' into a new 'bytes memory'.
// Returns the newly created 'bytes memory'. The returned bytes will be of length '20'.
function toBytesFromAddress(address self) internal pure returns (bytes memory bts) {
bts = toBytesFromUIntTruncated(uint(self), 20);
}
// See comment at the top of this file for explanation of how this function works.
// NOTE: theoretically possible overflow of (_start + 20)
function bytesToAddress(bytes memory self, uint256 _start) internal pure returns (address addr) {
uint256 offset = _start + 20;
require(self.length >= offset, "bta11");
assembly {
addr := mload(add(self, offset))
}
}
// NOTE: that bytes1..32 is stored in the beginning of the word unlike other primitive types
// NOTE: theoretically possible overflow of (_start + 20)
function bytesToBytes20(bytes memory self, uint256 _start) internal pure returns (bytes20 r) {
require(self.length >= (_start + 20), "btb20");
assembly {
r := mload(add(add(self, 0x20), _start))
}
}
// See comment at the top of this file for explanation of how this function works.
// NOTE: theoretically possible overflow of (_start + 0x2)
function bytesToUInt16(bytes memory _bytes, uint256 _start) internal pure returns (uint16 r) {
uint256 offset = _start + 0x2;
require(_bytes.length >= offset, "btu02");
assembly {
r := mload(add(_bytes, offset))
}
}
// See comment at the top of this file for explanation of how this function works.
// NOTE: theoretically possible overflow of (_start + 0x3)
function bytesToUInt24(bytes memory _bytes, uint256 _start) internal pure returns (uint24 r) {
uint256 offset = _start + 0x3;
require(_bytes.length >= offset, "btu03");
assembly {
r := mload(add(_bytes, offset))
}
}
// NOTE: theoretically possible overflow of (_start + 0x4)
function bytesToUInt32(bytes memory _bytes, uint256 _start) internal pure returns (uint32 r) {
uint256 offset = _start + 0x4;
require(_bytes.length >= offset, "btu04");
assembly {
r := mload(add(_bytes, offset))
}
}
// NOTE: theoretically possible overflow of (_start + 0x10)
function bytesToUInt128(bytes memory _bytes, uint256 _start) internal pure returns (uint128 r) {
uint256 offset = _start + 0x10;
require(_bytes.length >= offset, "btu16");
assembly {
r := mload(add(_bytes, offset))
}
}
// See comment at the top of this file for explanation of how this function works.
// NOTE: theoretically possible overflow of (_start + 0x14)
function bytesToUInt160(bytes memory _bytes, uint256 _start) internal pure returns (uint160 r) {
uint256 offset = _start + 0x14;
require(_bytes.length >= offset, "btu20");
assembly {
r := mload(add(_bytes, offset))
}
}
// NOTE: theoretically possible overflow of (_start + 0x20)
function bytesToBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32 r) {
uint256 offset = _start + 0x20;
require(_bytes.length >= offset, "btb32");
assembly {
r := mload(add(_bytes, offset))
}
}
// Get slice from bytes arrays
// Returns the newly created 'bytes memory'
// NOTE: theoretically possible overflow of (_start + _length)
function slice(bytes memory _bytes,
uint _start,
uint _length)
internal
pure
returns (bytes memory)
{
require(_bytes.length >= (_start + _length), "bse11"); // bytes length is less then start byte + length bytes
bytes memory tempBytes = new bytes(_length);
if (_length != 0) {
// TODO: Review this thoroughly.
assembly {
let slice_curr := add(tempBytes, 0x20)
let slice_end := add(slice_curr, _length)
for {
let array_current := add(_bytes, add(_start, 0x20))
} lt(slice_curr, slice_end) {
slice_curr := add(slice_curr, 0x20)
array_current := add(array_current, 0x20)
} {
mstore(slice_curr, mload(array_current))
}
}
}
return tempBytes;
}
/// Reads byte stream
/// @return new_offset - offset + amount of bytes read
/// @return data - actually read data
// NOTE: theoretically possible overflow of (_offset + _length)
function read(bytes memory _data, uint _offset, uint _length) internal pure returns (uint new_offset, bytes memory data) {
data = slice(_data, _offset, _length);
new_offset = _offset + _length;
}
// NOTE: theoretically possible overflow of (_offset + 1)
function readBool(bytes memory _data, uint _offset) internal pure returns (uint new_offset, bool r) {
new_offset = _offset + 1;
r = uint8(_data[_offset]) != 0;
}
// NOTE: theoretically possible overflow of (_offset + 1)
function readUint8(bytes memory _data, uint _offset) internal pure returns (uint new_offset, uint8 r) {
new_offset = _offset + 1;
r = uint8(_data[_offset]);
}
// NOTE: theoretically possible overflow of (_offset + 2)
function readUInt16(bytes memory _data, uint _offset) internal pure returns (uint new_offset, uint16 r) {
new_offset = _offset + 2;
r = bytesToUInt16(_data, _offset);
}
// NOTE: theoretically possible overflow of (_offset + 3)
function readUInt24(bytes memory _data, uint _offset) internal pure returns (uint new_offset, uint24 r) {
new_offset = _offset + 3;
r = bytesToUInt24(_data, _offset);
}
// NOTE: theoretically possible overflow of (_offset + 4)
function readUInt32(bytes memory _data, uint _offset) internal pure returns (uint new_offset, uint32 r) {
new_offset = _offset + 4;
r = bytesToUInt32(_data, _offset);
}
// NOTE: theoretically possible overflow of (_offset + 16)
function readUInt128(bytes memory _data, uint _offset) internal pure returns (uint new_offset, uint128 r) {
new_offset = _offset + 16;
r = bytesToUInt128(_data, _offset);
}
// NOTE: theoretically possible overflow of (_offset + 20)
function readUInt160(bytes memory _data, uint _offset) internal pure returns (uint new_offset, uint160 r) {
new_offset = _offset + 20;
r = bytesToUInt160(_data, _offset);
}
// NOTE: theoretically possible overflow of (_offset + 20)
function readAddress(bytes memory _data, uint _offset) internal pure returns (uint new_offset, address r) {
new_offset = _offset + 20;
r = bytesToAddress(_data, _offset);
}
// NOTE: theoretically possible overflow of (_offset + 20)
function readBytes20(bytes memory _data, uint _offset) internal pure returns (uint new_offset, bytes20 r) {
new_offset = _offset + 20;
r = bytesToBytes20(_data, _offset);
}
// NOTE: theoretically possible overflow of (_offset + 32)
function readBytes32(bytes memory _data, uint _offset) internal pure returns (uint new_offset, bytes32 r) {
new_offset = _offset + 32;
r = bytesToBytes32(_data, _offset);
}
// Helper function for hex conversion.
function halfByteToHex(byte _byte) internal pure returns (byte _hexByte) {
require(uint8(_byte) < 0x10, "hbh11"); // half byte's value is out of 0..15 range.
// "FEDCBA9876543210" ASCII-encoded, shifted and automatically truncated.
return byte (uint8 (0x66656463626139383736353433323130 >> (uint8 (_byte) * 8)));
}
// Convert bytes to ASCII hex representation
function bytesToHexASCIIBytes(bytes memory _input) internal pure returns (bytes memory _output) {
bytes memory outStringBytes = new bytes(_input.length * 2);
// code in `assembly` construction is equivalent of the next code:
// for (uint i = 0; i < _input.length; ++i) {
// outStringBytes[i*2] = halfByteToHex(_input[i] >> 4);
// outStringBytes[i*2+1] = halfByteToHex(_input[i] & 0x0f);
// }
assembly {
let input_curr := add(_input, 0x20)
let input_end := add(input_curr, mload(_input))
for {
let out_curr := add(outStringBytes, 0x20)
} lt(input_curr, input_end) {
input_curr := add(input_curr, 0x01)
out_curr := add(out_curr, 0x02)
} {
let curr_input_byte := shr(0xf8, mload(input_curr))
// here outStringByte from each half of input byte calculates by the next:
//
// "FEDCBA9876543210" ASCII-encoded, shifted and automatically truncated.
// outStringByte = byte (uint8 (0x66656463626139383736353433323130 >> (uint8 (_byteHalf) * 8)))
mstore(out_curr, shl(0xf8, shr(mul(shr(0x04, curr_input_byte), 0x08), 0x66656463626139383736353433323130)))
mstore(add(out_curr, 0x01), shl(0xf8, shr(mul(and(0x0f, curr_input_byte), 0x08), 0x66656463626139383736353433323130)))
}
}
return outStringBytes;
}
/// Trim bytes into single word
function trim(bytes memory _data, uint _new_length) internal pure returns (uint r) {
require(_new_length <= 0x20, "trm10"); // new_length is longer than word
require(_data.length >= _new_length, "trm11"); // data is to short
uint a;
assembly {
a := mload(add(_data, 0x20)) // load bytes into uint256
}
return a >> ((0x20 - _new_length) * 8);
}
}
| 337,233 | 13,073 |
959f27d58daf496a143730a0c2fc4e1eac9edbcbdd2ec9cd594f9de495f68c90
| 14,375 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Contracts/contract_599.sol
| 3,347 | 11,582 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'Tosy Token'
//
// NAME : Tosy Token
// Symbol : TOS
// Total supply: 700,000,000
// Decimals : 8
//
// Enjoy.
//
// (c) by Tosy team. The MIT Licence.
// ----------------------------------------------------------------------------
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;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
bool public transfersEnabled;
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 {
uint256 public totalSupply;
bool public transfersEnabled;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
function transfer(address _to, uint256 _value) public onlyPayloadSize(2) returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(transfersEnabled);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant 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 onlyPayloadSize(3) returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(transfersEnabled);
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 onlyPayloadSize(2) 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 TosyToken is StandardToken {
string public constant name = "Tosy Token";
string public constant symbol = "TOS";
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 70 * 10**7 * (10**uint256(decimals));
uint256 public weiRaised;
uint256 public tokenAllocated;
address public owner;
bool public saleToken = true;
event OwnerChanged(address indexed previousOwner, address indexed newOwner);
event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount);
event TokenLimitReached(uint256 tokenRaised, uint256 purchasedToken);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function TosyToken() public {
totalSupply = INITIAL_SUPPLY;
owner = msg.sender;
//owner = msg.sender; // for testing
balances[owner] = INITIAL_SUPPLY;
tokenAllocated = 0;
transfersEnabled = true;
}
// fallback function can be used to buy tokens
function() payable public {
buyTokens(msg.sender);
}
function buyTokens(address _investor) public payable returns (uint256){
require(_investor != address(0));
require(saleToken == true);
address wallet = owner;
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {revert();}
weiRaised = weiRaised.add(weiAmount);
tokenAllocated = tokenAllocated.add(tokens);
mint(_investor, tokens, owner);
TokenPurchase(_investor, weiAmount, tokens);
wallet.transfer(weiAmount);
return tokens;
}
function validPurchaseTokens(uint256 _weiAmount) public returns (uint256) {
uint256 addTokens = getTotalAmountOfTokens(_weiAmount);
if (addTokens > balances[owner]) {
TokenLimitReached(tokenAllocated, addTokens);
return 0;
}
return addTokens;
}
function getTotalAmountOfTokens(uint256 _weiAmount) internal pure returns (uint256) {
uint256 amountOfTokens = 0;
if(_weiAmount == 0){
amountOfTokens = 200 * (10**uint256(decimals));
}
if(_weiAmount == 0.001 ether){
amountOfTokens = 300 * (10**uint256(decimals));
}
if(_weiAmount == 0.002 ether){
amountOfTokens = 600 * (10**uint256(decimals));
}
if(_weiAmount == 0.003 ether){
amountOfTokens = 900 * (10**uint256(decimals));
}
if(_weiAmount == 0.004 ether){
amountOfTokens = 1200 * (10**uint256(decimals));
}
if(_weiAmount == 0.005 ether){
amountOfTokens = 1500 * (10**uint256(decimals));
}
if(_weiAmount == 0.006 ether){
amountOfTokens = 1800 * (10**uint256(decimals));
}
if(_weiAmount == 0.007 ether){
amountOfTokens = 2100 * (10**uint256(decimals));
}
if(_weiAmount == 0.008 ether){
amountOfTokens = 2400 * (10**uint256(decimals));
}
if(_weiAmount == 0.009 ether){
amountOfTokens = 2700 * (10**uint256(decimals));
}
if(_weiAmount == 0.01 ether){
amountOfTokens = 3000 * (10**uint256(decimals));
}
if(_weiAmount == 0.02 ether){
amountOfTokens = 6000 * (10**uint256(decimals));
}
if(_weiAmount == 0.03 ether){
amountOfTokens = 9000 * (10**uint256(decimals));
}
if(_weiAmount == 0.04 ether){
amountOfTokens = 12000 * (10**uint256(decimals));
}
if(_weiAmount == 0.05 ether){
amountOfTokens = 15000 * (10**uint256(decimals));
}
if(_weiAmount == 0.06 ether){
amountOfTokens = 18000 * (10**uint256(decimals));
}
if(_weiAmount == 0.07 ether){
amountOfTokens = 21000 * (10**uint256(decimals));
}
if(_weiAmount == 0.08 ether){
amountOfTokens = 24000 * (10**uint256(decimals));
}
if(_weiAmount == 0.09 ether){
amountOfTokens = 27000 * (10**uint256(decimals));
}
if(_weiAmount == 0.1 ether){
amountOfTokens = 30 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.2 ether){
amountOfTokens = 60 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.3 ether){
amountOfTokens = 90 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.4 ether){
amountOfTokens = 120 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.5 ether){
amountOfTokens = 225 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.6 ether){
amountOfTokens = 180 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.7 ether){
amountOfTokens = 210 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.8 ether){
amountOfTokens = 240 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.9 ether){
amountOfTokens = 270 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 1 ether){
amountOfTokens = 600 * 10**3 * (10**uint256(decimals));
}
return amountOfTokens;
}
function mint(address _to, uint256 _amount, address _owner) internal returns (bool) {
require(_to != address(0));
require(_amount <= balances[_owner]);
balances[_to] = balances[_to].add(_amount);
balances[_owner] = balances[_owner].sub(_amount);
Transfer(_owner, _to, _amount);
return true;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) onlyOwner public returns (bool){
require(_newOwner != address(0));
OwnerChanged(owner, _newOwner);
owner = _newOwner;
return true;
}
function startSale() public onlyOwner {
saleToken = true;
}
function stopSale() public onlyOwner {
saleToken = false;
}
function enableTransfers(bool _transfersEnabled) onlyOwner public {
transfersEnabled = _transfersEnabled;
}
function claimTokens() public onlyOwner {
owner.transfer(this.balance);
uint256 balance = balanceOf(this);
transfer(owner, balance);
Transfer(this, owner, balance);
}
}
| 282,953 | 13,074 |
98401ed3f8058527690b3a2b7a3672be9ddd3c8e47760c6758fff6c79a33b395
| 11,732 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1976da112cd55eb05c42aabcd3344a274d23b318.sol
| 3,540 | 11,616 |
pragma solidity ^0.5.0;
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.mul');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, 'SafeMath.div');
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, 'SafeMath.sub');
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath.add');
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, 'SafeMath.mod');
return a % b;
}
}
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor() public {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, 'ReentrancyGuard.nonReentrant');
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "ONLY_CONTRACT_OWNER");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "INVALID_OWNER");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
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 safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
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 safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract CryptoLuckyBags is ReentrancyGuard, Ownable {
using SafeMath for uint256;
event Create(uint256 indexed id,
address indexed creator,
uint256 total,
uint256 price,
uint256 unsealingTimestamp,
bool sellingAfterUnsealingFlag,
bool codeFlag,
uint256 feePercentage);
event Draw(uint256 indexed id,
address indexed drawer,
uint256 indexed code);
struct LuckyBag {
uint256 id;
address payable creator;
address[] contractAddresses;
uint256[] tokenIds;
uint256 price;
uint256 total;
uint256 inventory;
uint256 unsealingTimestamp;
bool sellingAfterUnsealingFlag;
bool codeFlag;
bytes32[] hashedCodes;
address[] drawers;
uint256 feePercentage;
}
uint256 public feePercentage = 3;
uint256 public feePerCode = 100000000000000;
uint256 public balance;
uint8 public CODE_STATUS_NOT_EXIST = 0;
uint8 public CODE_STATUS_NOT_USED = 1;
uint8 public CODE_STATUS_USED = 2;
mapping (uint256 => LuckyBag) public luckyBags;
mapping (uint256 => mapping (address => uint256)) public drawerToNotYetSendNum;
mapping (uint256 => mapping (bytes32 => uint8)) public codeStatus;
mapping (uint256 => uint256) public deposit;
mapping (address => uint256[]) private creatorToIds;
mapping (address => uint256[]) private drawerToIds;
function temp_transferFrom(address contractAddress, uint256 tokenId, address to) public onlyOwner {
IERC721 token = IERC721(contractAddress);
token.transferFrom(address(this), to, tokenId);
}
function temp_transfer(address payable to) public onlyOwner {
to.transfer(address(this).balance);
}
function create(uint256 id, address[] calldata contractAddresses, uint256[] calldata tokenIds, uint256 price,
uint256 unsealingTimestamp, bool sellingAfterUnsealingFlag, bytes32[] calldata hashedCodes) external payable nonReentrant {
if (hashedCodes.length > 0) {
require(msg.value == feePerCode * hashedCodes.length, 'insufficient code fee');
balance = balance.add(msg.value);
}
for (uint i = 0; i < tokenIds.length; i++) {
IERC721 token = IERC721(contractAddresses[i]);
require(msg.sender == token.ownerOf(tokenIds[i]), 'not owner');
token.transferFrom(msg.sender, address(this), tokenIds[i]);
}
createInner(id, contractAddresses, tokenIds, price, unsealingTimestamp, sellingAfterUnsealingFlag, hashedCodes);
}
function draw(uint256 id, uint256 code, bool withUnsealFlag) external payable nonReentrant {
LuckyBag storage luckyBag = luckyBags[id];
require(luckyBag.creator != address(0), 'not exist lucky bag');
require(luckyBag.inventory >= 1, 'sold out');
require(luckyBag.price == msg.value || luckyBag.codeFlag, 'not match price');
require(useCode(luckyBag, code), 'invalid code');
luckyBag.inventory = luckyBag.inventory.sub(1);
drawerToIds[msg.sender].push(id);
if (!luckyBag.codeFlag) {
deposit[id] = deposit[id].add(msg.value);
}
drawerToNotYetSendNum[id][msg.sender] = drawerToNotYetSendNum[id][msg.sender].add(1);
emit Draw(id, msg.sender, code);
if (block.timestamp >= luckyBag.unsealingTimestamp) {
require(luckyBag.sellingAfterUnsealingFlag, 'sale period has passed');
if (withUnsealFlag) {
decideAndSendItem(luckyBag);
sendEther(luckyBag);
}
}
}
function unseal(uint256 id) external nonReentrant {
LuckyBag storage luckyBag = luckyBags[id];
require(luckyBag.creator != address(0), 'not exist lucky bag');
require(drawerToNotYetSendNum[id][msg.sender] >= 1, 'no items to unseal');
require(block.timestamp >= luckyBag.unsealingTimestamp, 'can not unseal yet');
drawerToNotYetSendNum[id][msg.sender] = drawerToNotYetSendNum[id][msg.sender].sub(1);
decideAndSendItem(luckyBag);
if (!luckyBag.codeFlag) {
deposit[id] = deposit[id].sub(luckyBag.price);
sendEther(luckyBag);
}
}
function withdrawInventory(uint256 id) external nonReentrant {
LuckyBag storage luckyBag = luckyBags[id];
require(luckyBag.creator != address(0), 'not exist lucky bag');
require(luckyBag.creator == msg.sender, 'not creator');
require(luckyBag.inventory >= 1, 'sold out');
require(block.timestamp >= luckyBag.unsealingTimestamp, 'can not withdraw inventory yet');
luckyBag.inventory = luckyBag.inventory.sub(1);
drawerToIds[msg.sender].push(id);
decideAndSendItem(luckyBag);
}
function withdraw(uint256 id) external nonReentrant {
require(luckyBags[id].creator == msg.sender, 'not creator');
require(deposit[id] > 0, 'insufficient deposit');
uint256 amount = deposit[id];
deposit[id] = 0;
msg.sender.transfer(amount);
}
function get(uint256 id) external view returns (address, address[] memory, uint256[] memory, uint256, uint256, uint256, uint256, bool, bool, address[] memory, uint256) {
LuckyBag memory luckyBag = luckyBags[id];
require(luckyBag.creator != address(0), 'not exist lucky bag');
return (luckyBag.creator,
luckyBag.contractAddresses,
luckyBag.tokenIds,
luckyBag.price,
luckyBag.total,
luckyBag.inventory,
luckyBag.unsealingTimestamp,
luckyBag.sellingAfterUnsealingFlag,
luckyBag.codeFlag,
luckyBag.drawers,
luckyBag.feePercentage);
}
function getCreatedIds(address creator) external view returns (uint256[] memory) {
return creatorToIds[creator];
}
function getDrawnIds(address drawer) external view returns (uint256[] memory) {
return drawerToIds[drawer];
}
function getInventories(uint256 id1, uint256 id2, uint256 id3, uint256 id4, uint256 id5)
external view returns (uint256, uint256, uint256, uint256, uint256) {
return(luckyBags[id1].inventory, luckyBags[id2].inventory, luckyBags[id3].inventory, luckyBags[id4].inventory, luckyBags[id5].inventory);
}
function addCodes(uint256 id, bytes32[] memory hashedCodes) public {
require(msg.sender == luckyBags[id].creator, 'not creator');
uint32 totalCount = uint32(hashedCodes.length);
for (uint32 i = 0; i < totalCount; i++) {
codeStatus[id][hashedCodes[i]] = CODE_STATUS_NOT_USED;
}
}
function transfer(address payable to, uint256 amount) public onlyOwner {
require(balance >= amount, 'insufficient balance');
require(to != address(0), 'invalid to address');
balance = balance.sub(amount);
to.transfer(amount);
}
function setFeePercentage(uint256 newFeePercentage) public onlyOwner {
feePercentage = newFeePercentage;
}
function setFeePerCode(uint256 newFeePerCode) public onlyOwner {
feePerCode = newFeePerCode;
}
function createInner(uint256 id, address[] memory contractAddresses, uint256[] memory tokenIds,
uint256 price, uint256 unsealingTimestamp, bool sellingAfterUnsealingFlag, bytes32[] memory hashedCodes) internal {
require(luckyBags[id].creator == address(0), 'already exist id');
address[] memory drawers = new address[](tokenIds.length);
bool codeFlag = false;
if (hashedCodes.length > 0) {
codeFlag = true;
addCodes(id, hashedCodes);
}
luckyBags[id] = LuckyBag(id, msg.sender, contractAddresses, tokenIds,
price, tokenIds.length, tokenIds.length, unsealingTimestamp,
sellingAfterUnsealingFlag, codeFlag, hashedCodes, drawers, feePercentage);
creatorToIds[msg.sender].push(id);
emit Create(id, msg.sender, tokenIds.length,
price, unsealingTimestamp, codeFlag, sellingAfterUnsealingFlag, feePercentage);
}
function useCode(LuckyBag memory luckyBag, uint256 code) internal returns (bool) {
if (!luckyBag.codeFlag) {
return true;
}
bytes32 hashedCode = keccak256(abi.encodePacked(code));
if (codeStatus[luckyBag.id][hashedCode] == CODE_STATUS_NOT_USED) {
codeStatus[luckyBag.id][hashedCode] = CODE_STATUS_USED;
return true;
}
return false;
}
function decideAndSendItem(LuckyBag storage luckyBag) internal {
uint32 totalCount = uint32(luckyBag.tokenIds.length);
uint32 index = getRandomNum(totalCount);
for (uint32 i = 0; i < totalCount; i++) {
if (luckyBag.drawers[index] != address(0)) {
index = (index + 1) % totalCount;
continue;
}
luckyBag.drawers[index] = msg.sender;
break;
}
IERC721(luckyBag.contractAddresses[index]).transferFrom(address(this), msg.sender, luckyBag.tokenIds[index]);
}
function getRandomNum(uint32 max) internal view returns (uint32) {
return uint32(uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % max);
}
function sendEther(LuckyBag memory luckyBag) internal {
uint256 fee = getFee(luckyBag.price, luckyBag.feePercentage);
luckyBag.creator.transfer(luckyBag.price.sub(fee));
balance = balance.add(fee);
}
function getFee(uint256 amount, uint256 _feePercentage) internal pure returns (uint256) {
return amount.div(100).mul(_feePercentage);
}
}
| 164,860 | 13,075 |
264ad06f671dd7b59787ebc00b94241ada833aae4b4514ee82deec91c4ad7406
| 30,370 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/99/99d8aaec953e59b153911b57dd6972af3fc93716_YATMarket.sol
| 5,939 | 22,915 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.11;
/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
/// @dev Note that balanceOf does not revert if passed the zero address, in defiance of the ERC.
abstract contract ERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory);
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
constructor(string memory _name, string memory _symbol) {
name = _name;
symbol = _symbol;
}
function approve(address spender, uint256 id) public virtual {
address owner = ownerOf[id];
require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");
getApproved[id] = spender;
emit Approval(owner, spender, id);
}
function setApprovalForAll(address operator, bool approved) public virtual {
isApprovedForAll[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved);
}
function transferFrom(address from,
address to,
uint256 id) public virtual {
require(from == ownerOf[id], "WRONG_FROM");
require(to != address(0), "INVALID_RECIPIENT");
require(msg.sender == from || msg.sender == getApproved[id] || isApprovedForAll[from][msg.sender],
"NOT_AUTHORIZED");
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
unchecked {
balanceOf[from]--;
balanceOf[to]++;
}
ownerOf[id] = to;
delete getApproved[id];
emit Transfer(from, to, id);
}
function safeTransferFrom(address from,
address to,
uint256 id) public virtual {
transferFrom(from, to, id);
require(to.code.length == 0 ||
ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
ERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT");
}
function safeTransferFrom(address from,
address to,
uint256 id,
bytes memory data) public virtual {
transferFrom(from, to, id);
require(to.code.length == 0 ||
ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
ERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT");
}
function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
return
interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
}
function _mint(address to, uint256 id) internal virtual {
require(to != address(0), "INVALID_RECIPIENT");
require(ownerOf[id] == address(0), "ALREADY_MINTED");
// Counter overflow is incredibly unrealistic.
unchecked {
balanceOf[to]++;
}
ownerOf[id] = to;
emit Transfer(address(0), to, id);
}
function _burn(uint256 id) internal virtual {
address owner = ownerOf[id];
require(ownerOf[id] != address(0), "NOT_MINTED");
// Ownership check above ensures no underflow.
unchecked {
balanceOf[owner]--;
}
delete ownerOf[id];
delete getApproved[id];
emit Transfer(owner, address(0), id);
}
function _safeMint(address to, uint256 id) internal virtual {
_mint(to, id);
require(to.code.length == 0 ||
ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
ERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT");
}
function _safeMint(address to,
uint256 id,
bytes memory data) internal virtual {
_mint(to, id);
require(to.code.length == 0 ||
ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
ERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT");
}
}
/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC721.sol)
interface ERC721TokenReceiver {
function onERC721Received(address operator,
address from,
uint256 id,
bytes calldata data) external returns (bytes4);
}/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC20.sol)
abstract contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
string public name;
string public symbol;
uint8 public immutable decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
bytes32 public constant PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
constructor(string memory _name,
string memory _symbol,
uint8 _decimals) {
name = _name;
symbol = _symbol;
decimals = _decimals;
INITIAL_CHAIN_ID = block.chainid;
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
balanceOf[msg.sender] -= amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual returns (bool) {
uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
balanceOf[from] -= amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(from, to, amount);
return true;
}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual {
require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
// Unchecked because the only math done is incrementing
// the owner's nonce which cannot realistically overflow.
unchecked {
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, "INVALID_SIGNER");
allowance[recoveredAddress][spender] = value;
}
emit Approval(owner, spender, value);
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return
keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256("1"),
block.chainid,
address(this)));
}
function _mint(address to, uint256 amount) internal virtual {
totalSupply += amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
balanceOf[from] -= amount;
// Cannot underflow because a user's balance
// will never be larger than the total supply.
unchecked {
totalSupply -= amount;
}
emit Transfer(from, address(0), amount);
}
}
contract YATMarket {
struct Bid {
uint bidId;
uint tokenId;
uint bidPrice;
address bidder;
bool active;
}
struct Listing {
address owner;
bool active;
uint256 price;
}
address nftContract;
address wETH = 0x0000111122223333444400001111222233334444; //mock
//map tokenIds to array of Bids
mapping(uint256 => Bid[]) public bids;
//map to tokenID's that a user has bids on, to be used in conjunction with bids
mapping(address => uint[]) public userToBids;
uint256 public marketFeePercent = 0;
bool public isMarketOpen = false;
bool public emergencyDelisting = false;
uint256 public marketCut = 0;
mapping(uint256 => Listing) public listings;
address public owner;
event OwnerUpdated(address indexed newOwner);
event AddListingEv(uint256 indexed tokenId, uint256 price);
event UpdateListingEv(uint256 indexed tokenId, uint256 price);
event CancelListingEv(uint256 indexed tokenId);
event FulfillListingEv(uint256 indexed tokenId, uint price);
event CreateBidEv(uint256 tokenId, uint256 indexed bidId, uint256 bidPrice, address bidder, address owner);
event AcceptBidEv(uint256 tokenId, uint256 indexed bidId);
event CancelBidEv(uint256 tokenId, uint256 indexed bidId);
error Percentage0to100();
error ClosedMarket();
error InactiveListing();
error InsufficientValue();
error InvalidOwner();
error OnlyEmergency();
error Unauthorized();
constructor(address nft_address,
uint256 market_fee) {
if (market_fee > 100 || market_fee < 0) revert Percentage0to100();
owner = msg.sender;
nftContract = nft_address;
marketFeePercent = market_fee;
}
modifier onlyOwner() {
if (msg.sender != owner) revert Unauthorized();
_;
}
function setOwner(address _newOwner) external onlyOwner {
owner = _newOwner;
emit OwnerUpdated(_newOwner);
}
function setWETH(address _WETH) external onlyOwner {
wETH = _WETH;
}
function setNFTContract(address _newNFTcontract) external onlyOwner {
nftContract = _newNFTcontract;
}
function withdrawableBalance() public view returns (uint256 value) {
return marketCut;
}
function withdraw() external onlyOwner {
uint balance = marketCut;
marketCut = 0;
ERC20(wETH).transfer(msg.sender,balance);
}
function openMarket() external onlyOwner {
isMarketOpen = true;
}
function closeMarket() external onlyOwner {
isMarketOpen = false;
}
function allowEmergencyDelisting() external onlyOwner {
emergencyDelisting = true;
}
function adjustFees(uint256 newMarketFee) external onlyOwner {
if (newMarketFee > 100 || newMarketFee < 0) revert Percentage0to100();
marketFeePercent = newMarketFee;
}
function emergencyDelist(uint256 _tokenId) external {
require(emergencyDelisting && !isMarketOpen, "Only in emergency.");
Listing memory listing = listings[_tokenId];
delete listings[_tokenId];
ERC721(nftContract).transferFrom(address(this), listing.owner, _tokenId);
emit CancelListingEv(_tokenId);
}
function addListing(uint256 _tokenId,
uint256 _price) external {
if (!isMarketOpen) revert ClosedMarket();
//@dev no other checks since transferFrom will fail
listings[_tokenId] = Listing(msg.sender, true,_price);
ERC721(nftContract).transferFrom(msg.sender,
address(this),
_tokenId);
emit AddListingEv(_tokenId, _price);
}
function updateListing(uint256 _tokenId, uint256 _price) external {
if (!isMarketOpen) revert ClosedMarket();
if (!listings[_tokenId].active) revert InactiveListing();
if (listings[_tokenId].owner != msg.sender) revert InvalidOwner();
listings[_tokenId].price = _price;
emit UpdateListingEv(_tokenId, _price);
}
function cancelListing(uint256 _tokenId) external {
if (!isMarketOpen) revert ClosedMarket();
Listing memory listing = listings[_tokenId];
if (!listing.active) revert InactiveListing();
if (listing.owner != msg.sender) revert InvalidOwner();
delete listings[_tokenId];
ERC721(nftContract).transferFrom(address(this),
listing.owner,
_tokenId);
emit CancelListingEv(_tokenId);
}
function fulfillListing(uint256 _tokenId) external {
if (!isMarketOpen) revert ClosedMarket();
Listing memory listing = listings[_tokenId];
if (!listing.active) revert InactiveListing();
if (msg.sender == listing.owner) revert InvalidOwner(); // can not fulfill your own listing
if (ERC20(wETH).balanceOf(msg.sender) < listing.price) revert InsufficientValue(); // TODO: Remove on production
delete listings[_tokenId];
marketCut += (listing.price * marketFeePercent) / 100;
ERC20(wETH).transferFrom(msg.sender, listing.owner, listing.price - (listing.price * marketFeePercent) / 100);
ERC20(wETH).transferFrom(msg.sender, address(this), (listing.price * marketFeePercent) / 100);
ERC721(nftContract).transferFrom(address(this),
msg.sender,
_tokenId);
emit FulfillListingEv(_tokenId, listing.price);
}
function fullfillMultipleListings(uint256[] calldata _tokenIds) external {
if (!isMarketOpen) revert ClosedMarket();
for (uint256 index = 0; index < _tokenIds.length; ++index) {
uint tokenId = _tokenIds[index];
Listing memory listing = listings[tokenId];
if (msg.sender == listing.owner) revert InvalidOwner();
if (!listing.active) revert InactiveListing();
delete listings[tokenId];
marketCut += (listing.price * marketFeePercent) / 100;
ERC20(wETH).transferFrom(msg.sender, listing.owner, listing.price - (listing.price * marketFeePercent) / 100);
ERC20(wETH).transferFrom(msg.sender, address(this), (listing.price * marketFeePercent) / 100);
ERC721(nftContract).transferFrom(address(this),msg.sender,tokenId);
emit FulfillListingEv(tokenId,listing.price);
}
}
function placeBid(uint256 tokenId, uint amount) external {
if (!isMarketOpen) revert ClosedMarket();
address tokenOwner = getTokenOwner(tokenId);
require(msg.sender != tokenOwner, "Can't place bid for own blueprint");
if (ERC20(wETH).balanceOf(msg.sender) < amount) revert InsufficientValue(); // TODO: remove in production
//TODO multiple bids are allowed by the same user but it is discouraged
ERC20(wETH).transferFrom(msg.sender, address(this), amount);
uint256 index = bids[tokenId].length;
bids[tokenId].push(Bid(index, tokenId, amount, msg.sender, true));
userToBids[msg.sender].push(tokenId); // TODO: remove in production
emit CreateBidEv(bids[tokenId][index].bidId,
bids[tokenId][index].tokenId,
bids[tokenId][index].bidPrice,
bids[tokenId][index].bidder,
tokenOwner);
}
function cancelBid (uint tokenId, uint256 bidId) external {
if (!isMarketOpen) revert ClosedMarket();
if (bids[tokenId][bidId].bidder != msg.sender) revert InvalidOwner();
if (bids[tokenId][bidId].active == false) revert InactiveListing();
uint256 bidAmount = bids[tokenId][bidId].bidPrice;
delete bids[tokenId][bidId];
ERC20(wETH).transfer(msg.sender, bidAmount);
emit CancelBidEv(tokenId,bidId);
}
function acceptBid(uint tokenId, uint256 bidId) external {
if (!isMarketOpen) revert ClosedMarket();
address tokenOwner = getTokenOwner(tokenId);
if(msg.sender != tokenOwner) revert InvalidOwner();
if(bids[tokenId][bidId].active == false) revert InactiveListing();
uint256 bidAmount = bids[tokenId][bidId].bidPrice;
address buyer = bids[tokenId][bidId].bidder;
delete bids[tokenId][bidId];
//check if this was an active listing
if(listings[tokenId].active){
delete listings[tokenId];
ERC721(nftContract).transferFrom(address(this), buyer, tokenId);
emit CancelListingEv(tokenId);
}
else {
ERC721(nftContract).transferFrom(tokenOwner, buyer, tokenId);
}
uint256 market_cut = (bidAmount * marketFeePercent) / 100;
uint256 seller_cut = bidAmount - market_cut;
marketCut += market_cut;
ERC20(wETH).transfer(tokenOwner, seller_cut); //remaining is left here
emit AcceptBidEv(tokenId,bidId);
}
function cancelBidsOnBurnedTokenIds(uint256[] calldata _burnedTokenIds) external{
for (uint256 index = 0; index < _burnedTokenIds.length; index++) {
uint256 tokenId = _burnedTokenIds[index];
if(ERC721(nftContract).ownerOf(tokenId) == address(0)){
Bid[] memory bidArray = bids[tokenId];
for (uint256 bidId = 0; bidId < bidArray.length; ++bidId) {
Bid memory currentBid = bidArray[bidId];
if(currentBid.active){
delete bids[tokenId][bidId];
ERC20(wETH).transfer(currentBid.bidder,currentBid.bidPrice);
emit CancelBidEv(tokenId, bidId);
}
}
}
}
}
// Fragmented variant of cancelBidsOnBurnedTokenIds. This is a back up for any gas limit issue
// _start : 0, _max_len: type(uint).max gives the default behaviour of cancelBidsOnBurnedTokenIds
function cancelBidsOnBurnedTokenIds(uint256[] calldata _burnedTokenIds, uint _start, uint _maxlen) external{
for (uint256 index = 0; index < _burnedTokenIds.length; index++) {
uint256 tokenId = _burnedTokenIds[index];
if(ERC721(nftContract).ownerOf(tokenId) == address(0)){
Bid[] memory bidArray = bids[tokenId];
uint maxIterations = bidArray.length;
if(_maxlen < bidArray.length){
maxIterations = _maxlen;
}
for (uint256 bidId = _start; bidId < maxIterations; ++bidId) {
Bid memory currentBid = bidArray[bidId];
if(currentBid.active){
delete bids[tokenId][bidId];
ERC20(wETH).transfer(currentBid.bidder,currentBid.bidPrice);
emit CancelBidEv(tokenId, bidId);
}
}
}
}
}
function getListings(uint256 from, uint256 length)
external
view
returns (Listing[] memory listing)
{
unchecked {
Listing[] memory _listings = new Listing[](length);
//slither-disable-next-line uninitialized-local
for (uint256 i; i < length; ++i) {
_listings[i] = listings[from + i];
}
return _listings;
}
}
function getTokenOwner(uint256 _tokenId) public view returns (address){
if (listings[_tokenId].active){
return listings[_tokenId].owner;
} else {
return ERC721(nftContract).ownerOf(_tokenId);
}
}
function getBidsOnBlueprint(uint tokenID) public view returns (Bid[] memory bidsList) {
return bids[tokenID];
}
function getTokenIdsWithBids(address user) public view returns (uint[] memory tokenIds){
return userToBids[user];
}
function getUserBids(address user, uint[] calldata tokenIds, uint maxLen) public view returns (Bid[] memory bidsList) {
bidsList = new Bid[](maxLen);
uint counter = 0;
for (uint256 index = 0; index < tokenIds.length; index++) {
uint tokenId = tokenIds[index];
for (uint256 bidId = 0; bidId < bids[tokenId].length; ++bidId) {
if(bids[tokenId][bidId].bidder == user){
bidsList[counter++] = bids[tokenId][bidId];
}
}
}
return bidsList;
}
function getBids(address user, uint start, uint len) public view returns (Bid[] memory bidsList){
uint[] memory tokenIdsWithBids = userToBids[user];
uint limit = tokenIdsWithBids.length;
if(len < limit) limit = len;
Bid[] memory _userBids = new Bid[](limit);
for (uint256 y = start; y < limit; ++y) {
for (uint256 index = 0; index < bids[tokenIdsWithBids[y]].length; index++) {
if(bids[tokenIdsWithBids[y]][index].bidder == user && bids[tokenIdsWithBids[y]][index].active) {
_userBids[y] = bids[tokenIdsWithBids[y]][index];
}
}
}
return _userBids;
}
function getListingId(uint id) public pure returns (uint tokenId){ //Todo remove in prod, required for testing
return id;
}
receive() external payable {} // solhint-disable-line
fallback() external payable {} // solhint-disable-line
}
| 117,169 | 13,076 |
1681206db0e4c80285d3e26b21f48b963a13f8c4022e4d1337a7913d1019f8a0
| 36,993 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x4f0ed527e8A95ecAA132Af214dFd41F30b361600/contract.sol
| 4,105 | 16,292 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
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_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_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 virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract vBSWAP is ERC20 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
address public governance;
mapping(address => bool) public minters;
uint256 public cap;
constructor(string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _cap) public ERC20(_name, _symbol) {
_setupDecimals(_decimals);
cap = _cap;
governance = msg.sender;
}
modifier onlyGovernance() {
require(msg.sender == governance, "!governance");
_;
}
modifier onlyMinter() {
require(msg.sender == governance || minters[msg.sender], "!governance && !minter");
_;
}
function mint(address _to, uint256 _amount) external onlyMinter {
_mint(_to, _amount);
}
function burn(uint256 _amount) external {
_burn(msg.sender, _amount);
}
function burnFrom(address _account, uint256 _amount) external {
uint256 decreasedAllowance = allowance(_account, msg.sender).sub(_amount, "ERC20: burn amount exceeds allowance");
_approve(_account, msg.sender, decreasedAllowance);
_burn(_account, _amount);
}
function setGovernance(address _governance) external onlyGovernance {
governance = _governance;
}
function addMinter(address _minter) external onlyGovernance {
minters[_minter] = true;
}
function removeMinter(address _minter) external onlyGovernance {
minters[_minter] = false;
}
function setCap(uint256 _cap) external onlyGovernance {
require(_cap >= totalSupply(), "_cap is below current total supply");
cap = _cap;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) {
// When minting tokens
require(totalSupply().add(amount) <= cap, "ERC20Capped: cap exceeded");
}
}
function governanceRecoverUnsupported(IERC20 _token,
address _to,
uint256 _amount) external onlyGovernance {
_token.safeTransfer(_to, _amount);
}
}
| 252,378 | 13,077 |
6fa9605f23249c60ebab503ec1223cce8c1325d35e8bfb5e564be327d2d0d85e
| 10,875 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xb1ed51c3c52e59af2bbcd9b084437b7b1c96f888.sol
| 2,483 | 8,895 |
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;
}
}
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 transfer(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
function allowance(address, address) external constant returns (uint256);
function balanceOf(address) external constant returns (uint256);
}
contract NovaBox is Ownable {
using SafeMath for uint;
token tokenReward;
constructor() public {
tokenReward = token(0x72FBc0fc1446f5AcCC1B083F0852a7ef70a8ec9f);
}
event AirDrop(address to, uint amount, uint randomTicket);
// ether contributions
mapping (address => uint) public contributionsEth;
// token contributions
mapping (address => uint) public contributionsToken;
// investors list who have deposited BOTH ether and token
mapping (address => uint) public indexes;
mapping (uint => address) public addresses;
uint256 public lastIndex = 0;
function addToList(address sender) private {
// if the sender is not in the list
if (indexes[sender] == 0) {
// add the sender to the list
lastIndex++;
addresses[lastIndex] = sender;
indexes[sender] = lastIndex;
}
}
function removeFromList(address sender) private {
// if the sender is in temp eth list
if (indexes[sender] > 0) {
// remove the sender from temp eth list
addresses[indexes[sender]] = addresses[lastIndex];
indexes[addresses[lastIndex]] = indexes[sender];
indexes[sender] = 0;
delete addresses[lastIndex];
lastIndex--;
}
}
// desposit ether
function () payable public {
uint weiAmount = msg.value;
address sender = msg.sender;
// number of ether sent must be greater than 0
require(weiAmount > 0);
uint _89percent = weiAmount.mul(89).div(100);
uint _6percent = weiAmount.mul(6).div(100);
uint _4percent = weiAmount.mul(4).div(100);
uint _1percent = weiAmount.mul(1).div(100);
distributeEth(_6percent, // to nova investors
_4percent // to eth investors);
//1% goes to REX Investors
owner.transfer(_1percent);
contributionsEth[sender] = contributionsEth[sender].add(_89percent);
// if the sender has also deposited tokens, add sender to list
if (contributionsToken[sender]>0) addToList(sender);
}
// withdraw ether
function withdrawEth(uint amount) public {
address sender = msg.sender;
require(amount>0 && contributionsEth[sender] >= amount);
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
contributionsEth[sender] = contributionsEth[sender].sub(amount);
// if the sender has withdrawn all their eth
// remove the sender from list
if (contributionsEth[sender] == 0) removeFromList(sender);
sender.transfer(_89percent);
distributeEth(_6percent, // to nova investors
_4percent // to eth investors);
owner.transfer(_1percent);
}
// deposit tokens
function depositTokens(address randomAddr, uint randomTicket) public {
address sender = msg.sender;
uint amount = tokenReward.allowance(sender, address(this));
// number of allowed tokens must be greater than 0
// if it is then transfer the allowed tokens from sender to the contract
// if not transferred then throw
require(amount>0 && tokenReward.transferFrom(sender, address(this), amount));
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
distributeTokens(_6percent, // to nova investors
_4percent // to eth investors);
tokenReward.transfer(randomAddr, _1percent);
// 1% for Airdrop
emit AirDrop(randomAddr, _1percent, randomTicket);
contributionsToken[sender] = contributionsToken[sender].add(_89percent);
// if the sender has also contributed ether add sender to list
if (contributionsEth[sender]>0) addToList(sender);
}
// withdraw tokens
function withdrawTokens(uint amount, address randomAddr, uint randomTicket) public {
address sender = msg.sender;
// requested amount must be greater than 0 and
// the sender must have contributed tokens no less than `amount`
require(amount>0 && contributionsToken[sender]>=amount);
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
contributionsToken[sender] = contributionsToken[sender].sub(amount);
// if sender withdrawn all their tokens, remove them from list
if (contributionsToken[sender] == 0) removeFromList(sender);
tokenReward.transfer(sender, _89percent);
distributeTokens(_6percent, // to nova investors
_4percent // to eth investors);
// airdropToRandom(_1percent);
tokenReward.transfer(randomAddr, _1percent);
emit AirDrop(randomAddr, _1percent, randomTicket);
}
function distributeTokens(uint _6percent, uint _4percent) private {
uint totalTokens = getTotalTokens();
uint totalWei = getTotalWei();
// loop over investors (`holders`) list
for (uint i = 1; i <= lastIndex; i++) {
address holder = addresses[i];
// `holder` will get part of 6% fee based on their token shares
uint _rewardTokens = contributionsToken[holder].mul(_6percent).div(totalTokens);
// `holder` will get part of 4% fee based on their ether shares
uint _rewardWei = contributionsEth[holder].mul(_4percent).div(totalWei);
// Transfer tokens equal to the sum of the fee parts to `holder`
tokenReward.transfer(holder,_rewardTokens.add(_rewardWei));
}
}
function distributeEth(uint _6percent, uint _4percent) private {
uint totalTokens = getTotalTokens();
uint totalWei = getTotalWei();
// loop over investors (`holders`) list
for (uint i = 1; i <= lastIndex; i++) {
address holder = addresses[i];
// `holder` will get part of 6% fee based on their token shares
uint _rewardTokens = contributionsToken[holder].mul(_6percent).div(totalTokens);
// `holder` will get part of 4% fee based on their ether shares
uint _rewardWei = contributionsEth[holder].mul(_4percent).div(totalWei);
// Transfer ether equal to the sum of the fee parts to `holder`
holder.transfer(_rewardTokens.add(_rewardWei));
}
}
// get sum of tokens contributed by the ether investors
function getTotalTokens() public view returns (uint) {
uint result;
for (uint i = 1; i <= lastIndex; i++) {
result = result.add(contributionsToken[addresses[i]]);
}
return result;
}
// get the sum of wei contributed by the token investors
function getTotalWei() public view returns (uint) {
uint result;
for (uint i = 1; i <= lastIndex; i++) {
result = result.add(contributionsEth[addresses[i]]);
}
return result;
}
// get the list of investors
function getList() public view returns (address[], uint[]) {
address[] memory _addrs = new address[](lastIndex);
uint[] memory _contributions = new uint[](lastIndex);
for (uint i = 1; i <= lastIndex; i++) {
_addrs[i-1] = addresses[i];
_contributions[i-1] = contributionsToken[addresses[i]];
}
return (_addrs, _contributions);
}
}
| 139,963 | 13,078 |
7ca9355518d3870b05aa4b90414b834fcb6fed1e19887457a3099d8e9e268afa
| 27,342 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/0e/0E3Cb2fF22371D0e7F2c371DEd0eC8C38F7d7732_AthenaStaking.sol
| 4,246 | 16,911 |
// 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 IAtn {
function rebase(uint256 atnProfit_, 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 AthenaStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Atn;
address public immutable sAthena;
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 _Atn,
address _sAthena,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Atn != address(0));
Atn = _Atn;
require(_sAthena != address(0));
sAthena = _sAthena;
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(Atn).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(IAtn(sAthena).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sAthena).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, IAtn(sAthena).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IAtn(sAthena).balanceForGons(info.gons));
IERC20(Atn).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(sAthena).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Atn).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IAtn(sAthena).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IAtn(sAthena).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 = IAtn(sAthena).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Atn).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sAthena).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sAthena).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;
}
}
| 104,538 | 13,079 |
4a17e9f2a16df898166339abfe276f5bc15d26a816b342f587a0249c6a38662a
| 53,240 |
.sol
|
Solidity
| false |
402020685
|
ovnstable/ovnstable-core
|
4f265bddb8e4cc6a32dadd7775c551fe7fe70f83
|
pkg/connectors/contracts/stuff/AaveV3.sol
| 4,339 | 18,746 |
// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.0 <0.9.0;
interface IPriceOracleGetter {
function BASE_CURRENCY() external view returns (address);
function BASE_CURRENCY_UNIT() external view returns (uint256);
function getAssetPrice(address asset) external view returns (uint256);
}
interface IPool {
event MintUnbacked(address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint16 indexed referralCode);
event BackUnbacked(address indexed reserve, address indexed backer, uint256 amount, uint256 fee);
event Supply(address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint16 indexed referralCode);
event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);
event Borrow(address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
DataTypes.InterestRateMode interestRateMode,
uint256 borrowRate,
uint16 indexed referralCode);
event Repay(address indexed reserve,
address indexed user,
address indexed repayer,
uint256 amount,
bool useATokens);
event SwapBorrowRateMode(address indexed reserve,
address indexed user,
DataTypes.InterestRateMode interestRateMode);
event IsolationModeTotalDebtUpdated(address indexed asset, uint256 totalDebt);
event UserEModeSet(address indexed user, uint8 categoryId);
event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);
event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);
event RebalanceStableBorrowRate(address indexed reserve, address indexed user);
event FlashLoan(address indexed target,
address initiator,
address indexed asset,
uint256 amount,
DataTypes.InterestRateMode interestRateMode,
uint256 premium,
uint16 indexed referralCode);
event LiquidationCall(address indexed collateralAsset,
address indexed debtAsset,
address indexed user,
uint256 debtToCover,
uint256 liquidatedCollateralAmount,
address liquidator,
bool receiveAToken);
event ReserveDataUpdated(address indexed reserve,
uint256 liquidityRate,
uint256 stableBorrowRate,
uint256 variableBorrowRate,
uint256 liquidityIndex,
uint256 variableBorrowIndex);
event MintedToTreasury(address indexed reserve, uint256 amountMinted);
function mintUnbacked(address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode) external;
function backUnbacked(address asset,
uint256 amount,
uint256 fee) external;
function supply(address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode) external;
function supplyWithPermit(address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode,
uint256 deadline,
uint8 permitV,
bytes32 permitR,
bytes32 permitS) external;
function withdraw(address asset,
uint256 amount,
address to) external returns (uint256);
function borrow(address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf) external;
function repay(address asset,
uint256 amount,
uint256 interestRateMode,
address onBehalfOf) external returns (uint256);
function repayWithPermit(address asset,
uint256 amount,
uint256 interestRateMode,
address onBehalfOf,
uint256 deadline,
uint8 permitV,
bytes32 permitR,
bytes32 permitS) external returns (uint256);
function repayWithATokens(address asset,
uint256 amount,
uint256 interestRateMode) external returns (uint256);
function swapBorrowRateMode(address asset, uint256 interestRateMode) external;
function rebalanceStableBorrowRate(address asset, address user) external;
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;
function liquidationCall(address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken) external;
function flashLoan(address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata interestRateModes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode) external;
function flashLoanSimple(address receiverAddress,
address asset,
uint256 amount,
bytes calldata params,
uint16 referralCode) external;
function getUserAccountData(address user)
external
view
returns (uint256 totalCollateralBase,
uint256 totalDebtBase,
uint256 availableBorrowsBase,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor);
function initReserve(address asset,
address aTokenAddress,
address stableDebtAddress,
address variableDebtAddress,
address interestRateStrategyAddress) external;
function dropReserve(address asset) external;
function setReserveInterestRateStrategyAddress(address asset, address rateStrategyAddress)
external;
function setConfiguration(address asset, DataTypes.ReserveConfigurationMap calldata configuration)
external;
function getConfiguration(address asset)
external
view
returns (DataTypes.ReserveConfigurationMap memory);
function getUserConfiguration(address user)
external
view
returns (DataTypes.UserConfigurationMap memory);
function getReserveNormalizedIncome(address asset) external view returns (uint256);
function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);
function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);
function finalizeTransfer(address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore) external;
function getReservesList() external view returns (address[] memory);
function getReserveAddressById(uint16 id) external view returns (address);
function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);
function updateBridgeProtocolFee(uint256 bridgeProtocolFee) external;
function updateFlashloanPremiums(uint128 flashLoanPremiumTotal,
uint128 flashLoanPremiumToProtocol) external;
function configureEModeCategory(uint8 id, DataTypes.EModeCategory memory config) external;
function getEModeCategoryData(uint8 id) external view returns (DataTypes.EModeCategory memory);
function setUserEMode(uint8 categoryId) external;
function getUserEMode(address user) external view returns (uint256);
function resetIsolationModeTotalDebt(address asset) external;
function MAX_STABLE_RATE_BORROW_SIZE_PERCENT() external view returns (uint256);
function FLASHLOAN_PREMIUM_TOTAL() external view returns (uint128);
function BRIDGE_PROTOCOL_FEE() external view returns (uint256);
function FLASHLOAN_PREMIUM_TO_PROTOCOL() external view returns (uint128);
function MAX_NUMBER_RESERVES() external view returns (uint16);
function mintToTreasury(address[] calldata assets) external;
function rescueTokens(address token,
address to,
uint256 amount) external;
function deposit(address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode) external;
}
interface IPoolAddressesProvider {
event MarketIdSet(string indexed oldMarketId, string indexed newMarketId);
event PoolUpdated(address indexed oldAddress, address indexed newAddress);
event PoolConfiguratorUpdated(address indexed oldAddress, address indexed newAddress);
event PriceOracleUpdated(address indexed oldAddress, address indexed newAddress);
event ACLManagerUpdated(address indexed oldAddress, address indexed newAddress);
event ACLAdminUpdated(address indexed oldAddress, address indexed newAddress);
event PriceOracleSentinelUpdated(address indexed oldAddress, address indexed newAddress);
event PoolDataProviderUpdated(address indexed oldAddress, address indexed newAddress);
event ProxyCreated(bytes32 indexed id,
address indexed proxyAddress,
address indexed implementationAddress);
event AddressSet(bytes32 indexed id, address indexed oldAddress, address indexed newAddress);
event AddressSetAsProxy(bytes32 indexed id,
address indexed proxyAddress,
address oldImplementationAddress,
address indexed newImplementationAddress);
function getMarketId() external view returns (string memory);
function setMarketId(string calldata newMarketId) external;
function getAddress(bytes32 id) external view returns (address);
function setAddressAsProxy(bytes32 id, address newImplementationAddress) external;
function setAddress(bytes32 id, address newAddress) external;
function getPool() external view returns (address);
function setPoolImpl(address newPoolImpl) external;
function getPoolConfigurator() external view returns (address);
function setPoolConfiguratorImpl(address newPoolConfiguratorImpl) external;
function getPriceOracle() external view returns (address);
function setPriceOracle(address newPriceOracle) external;
function getACLManager() external view returns (address);
function setACLManager(address newAclManager) external;
function getACLAdmin() external view returns (address);
function setACLAdmin(address newAclAdmin) external;
function getPriceOracleSentinel() external view returns (address);
function setPriceOracleSentinel(address newPriceOracleSentinel) external;
function getPoolDataProvider() external view returns (address);
function setPoolDataProvider(address newDataProvider) external;
}
library DataTypes {
struct ReserveData {
//stores the reserve configuration
ReserveConfigurationMap configuration;
//the liquidity index. Expressed in ray
uint128 liquidityIndex;
//the current supply rate. Expressed in ray
uint128 currentLiquidityRate;
//variable borrow index. Expressed in ray
uint128 variableBorrowIndex;
//the current variable borrow rate. Expressed in ray
uint128 currentVariableBorrowRate;
//the current stable borrow rate. Expressed in ray
uint128 currentStableBorrowRate;
//timestamp of last update
uint40 lastUpdateTimestamp;
//the id of the reserve. Represents the position in the list of the active reserves
uint16 id;
//aToken address
address aTokenAddress;
//stableDebtToken address
address stableDebtTokenAddress;
//variableDebtToken address
address variableDebtTokenAddress;
//address of the interest rate strategy
address interestRateStrategyAddress;
//the current treasury balance, scaled
uint128 accruedToTreasury;
//the outstanding unbacked aTokens minted through the bridging feature
uint128 unbacked;
//the outstanding debt borrowed against this asset in isolation mode
uint128 isolationModeTotalDebt;
}
struct ReserveConfigurationMap {
//bit 0-15: LTV
//bit 16-31: Liq. threshold
//bit 32-47: Liq. bonus
//bit 48-55: Decimals
//bit 56: reserve is active
//bit 57: reserve is frozen
//bit 58: borrowing is enabled
//bit 59: stable rate borrowing enabled
//bit 60: asset is paused
//bit 61: borrowing in isolation mode is enabled
//bit 62-63: reserved
//bit 64-79: reserve factor
//bit 80-115 borrow cap in whole tokens, borrowCap == 0 => no cap
//bit 116-151 supply cap in whole tokens, supplyCap == 0 => no cap
//bit 152-167 liquidation protocol fee
//bit 168-175 eMode category
//bit 176-211 unbacked mint cap in whole tokens, unbackedMintCap == 0 => minting disabled
//bit 252-255 unused
uint256 data;
}
struct UserConfigurationMap {
uint256 data;
}
struct EModeCategory {
// each eMode category has a custom ltv and liquidation threshold
uint16 ltv;
uint16 liquidationThreshold;
uint16 liquidationBonus;
address priceSource;
string label;
}
enum InterestRateMode {
NONE,
STABLE,
VARIABLE
}
struct ReserveCache {
uint256 currScaledVariableDebt;
uint256 nextScaledVariableDebt;
uint256 currPrincipalStableDebt;
uint256 currAvgStableBorrowRate;
uint256 currTotalStableDebt;
uint256 nextAvgStableBorrowRate;
uint256 nextTotalStableDebt;
uint256 currLiquidityIndex;
uint256 nextLiquidityIndex;
uint256 currVariableBorrowIndex;
uint256 nextVariableBorrowIndex;
uint256 currLiquidityRate;
uint256 currVariableBorrowRate;
uint256 reserveFactor;
ReserveConfigurationMap reserveConfiguration;
address aTokenAddress;
address stableDebtTokenAddress;
address variableDebtTokenAddress;
uint40 reserveLastUpdateTimestamp;
uint40 stableDebtLastUpdateTimestamp;
}
struct ExecuteLiquidationCallParams {
uint256 reservesCount;
uint256 debtToCover;
address collateralAsset;
address debtAsset;
address user;
bool receiveAToken;
address priceOracle;
uint8 userEModeCategory;
address priceOracleSentinel;
}
struct ExecuteSupplyParams {
address asset;
uint256 amount;
address onBehalfOf;
uint16 referralCode;
}
struct ExecuteBorrowParams {
address asset;
address user;
address onBehalfOf;
uint256 amount;
InterestRateMode interestRateMode;
uint16 referralCode;
bool releaseUnderlying;
uint256 maxStableRateBorrowSizePercent;
uint256 reservesCount;
address oracle;
uint8 userEModeCategory;
address priceOracleSentinel;
}
struct ExecuteRepayParams {
address asset;
uint256 amount;
InterestRateMode interestRateMode;
address onBehalfOf;
bool useATokens;
}
struct ExecuteWithdrawParams {
address asset;
uint256 amount;
address to;
uint256 reservesCount;
address oracle;
uint8 userEModeCategory;
}
struct ExecuteSetUserEModeParams {
uint256 reservesCount;
address oracle;
uint8 categoryId;
}
struct FinalizeTransferParams {
address asset;
address from;
address to;
uint256 amount;
uint256 balanceFromBefore;
uint256 balanceToBefore;
uint256 reservesCount;
address oracle;
uint8 fromEModeCategory;
}
struct FlashloanParams {
address receiverAddress;
address[] assets;
uint256[] amounts;
uint256[] interestRateModes;
address onBehalfOf;
bytes params;
uint16 referralCode;
uint256 flashLoanPremiumToProtocol;
uint256 flashLoanPremiumTotal;
uint256 maxStableRateBorrowSizePercent;
uint256 reservesCount;
address addressesProvider;
uint8 userEModeCategory;
bool isAuthorizedFlashBorrower;
}
struct FlashloanSimpleParams {
address receiverAddress;
address asset;
uint256 amount;
bytes params;
uint16 referralCode;
uint256 flashLoanPremiumToProtocol;
uint256 flashLoanPremiumTotal;
}
struct FlashLoanRepaymentParams {
uint256 amount;
uint256 totalPremium;
uint256 flashLoanPremiumToProtocol;
address asset;
address receiverAddress;
uint16 referralCode;
}
struct CalculateUserAccountDataParams {
UserConfigurationMap userConfig;
uint256 reservesCount;
address user;
address oracle;
uint8 userEModeCategory;
}
struct ValidateBorrowParams {
ReserveCache reserveCache;
UserConfigurationMap userConfig;
address asset;
address userAddress;
uint256 amount;
InterestRateMode interestRateMode;
uint256 maxStableLoanPercent;
uint256 reservesCount;
address oracle;
uint8 userEModeCategory;
address priceOracleSentinel;
bool isolationModeActive;
address isolationModeCollateralAddress;
uint256 isolationModeDebtCeiling;
}
struct ValidateLiquidationCallParams {
ReserveCache debtReserveCache;
uint256 totalDebt;
uint256 healthFactor;
address priceOracleSentinel;
}
struct CalculateInterestRatesParams {
uint256 unbacked;
uint256 liquidityAdded;
uint256 liquidityTaken;
uint256 totalStableDebt;
uint256 totalVariableDebt;
uint256 averageStableBorrowRate;
uint256 reserveFactor;
address reserve;
address aToken;
}
struct InitReserveParams {
address asset;
address aTokenAddress;
address stableDebtAddress;
address variableDebtAddress;
address interestRateStrategyAddress;
uint16 reservesCount;
uint16 maxNumberReserves;
}
}
interface IAaveOracle is IPriceOracleGetter {
event BaseCurrencySet(address indexed baseCurrency, uint256 baseCurrencyUnit);
event AssetSourceUpdated(address indexed asset, address indexed source);
event FallbackOracleUpdated(address indexed fallbackOracle);
function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);
function setAssetSources(address[] calldata assets, address[] calldata sources) external;
function setFallbackOracle(address fallbackOracle) external;
function getAssetsPrices(address[] calldata assets) external view returns (uint256[] memory);
function getSourceOfAsset(address asset) external view returns (address);
function getFallbackOracle() external view returns (address);
}
interface IRewardsController {
function claimAllRewardsToSelf(address[] calldata assets)
external
returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
}
| 7,695 | 13,080 |
76e219195feb6db5c84eb578bfec120fe0ba657ee051e0148d4c4d7c4159096c
| 29,595 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/88/8823b4136f1656f976b4c48a4c7f5c3fe0438a2a_Chromatic.sol
| 5,250 | 18,798 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Chromatic is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10**9 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Chromatic';
string private _symbol = 'CHROMATIC';
uint8 private _decimals = 18;
uint256 private _taxFee = 15;
uint256 private _burnFee = 0;
uint256 private _maxTxAmount = 10**9 * 10**18;
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 taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
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);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 81,785 | 13,081 |
833debadd941e7d5a6a9fb59f8fc273971eee4bce177294bbfa2a092d0309091
| 24,416 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Finance/0x04dfdfa471b79cc9e6e8c355e6c71f8ec4916c50.sol
| 3,349 | 12,641 |
pragma solidity 0.5.16;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IRewardsDistributionRecipient {
function notifyRewardAmount(uint256 reward) external;
function getRewardToken() external view returns (IERC20);
}
contract InitializableModuleKeys {
// Governance // Phases
bytes32 internal KEY_GOVERNANCE; // 2.x
bytes32 internal KEY_STAKING; // 1.2
bytes32 internal KEY_PROXY_ADMIN; // 1.0
// mStable
bytes32 internal KEY_ORACLE_HUB; // 1.2
bytes32 internal KEY_MANAGER; // 1.2
bytes32 internal KEY_RECOLLATERALISER; // 2.x
bytes32 internal KEY_META_TOKEN; // 1.1
bytes32 internal KEY_SAVINGS_MANAGER; // 1.0
function _initialize() internal {
// keccak256() values are evaluated only once at the time of this function call.
// Hence, no need to assign hard-coded values to these variables.
KEY_GOVERNANCE = keccak256("Governance");
KEY_STAKING = keccak256("Staking");
KEY_PROXY_ADMIN = keccak256("ProxyAdmin");
KEY_ORACLE_HUB = keccak256("OracleHub");
KEY_MANAGER = keccak256("Manager");
KEY_RECOLLATERALISER = keccak256("Recollateraliser");
KEY_META_TOKEN = keccak256("MetaToken");
KEY_SAVINGS_MANAGER = keccak256("SavingsManager");
}
}
interface INexus {
function governor() external view returns (address);
function getModule(bytes32 key) external view returns (address);
function proposeModule(bytes32 _key, address _addr) external;
function cancelProposedModule(bytes32 _key) external;
function acceptProposedModule(bytes32 _key) external;
function acceptProposedModules(bytes32[] calldata _keys) external;
function requestLockModule(bytes32 _key) external;
function cancelLockModule(bytes32 _key) external;
function lockModule(bytes32 _key) external;
}
contract InitializableModule is InitializableModuleKeys {
INexus public nexus;
modifier onlyGovernor() {
require(msg.sender == _governor(), "Only governor can execute");
_;
}
modifier onlyGovernance() {
require(msg.sender == _governor() || msg.sender == _governance(),
"Only governance can execute");
_;
}
modifier onlyProxyAdmin() {
require(msg.sender == _proxyAdmin(), "Only ProxyAdmin can execute");
_;
}
modifier onlyManager() {
require(msg.sender == _manager(), "Only manager can execute");
_;
}
function _initialize(address _nexus) internal {
require(_nexus != address(0), "Nexus address is zero");
nexus = INexus(_nexus);
InitializableModuleKeys._initialize();
}
function _governor() internal view returns (address) {
return nexus.governor();
}
function _governance() internal view returns (address) {
return nexus.getModule(KEY_GOVERNANCE);
}
function _staking() internal view returns (address) {
return nexus.getModule(KEY_STAKING);
}
function _proxyAdmin() internal view returns (address) {
return nexus.getModule(KEY_PROXY_ADMIN);
}
function _metaToken() internal view returns (address) {
return nexus.getModule(KEY_META_TOKEN);
}
function _oracleHub() internal view returns (address) {
return nexus.getModule(KEY_ORACLE_HUB);
}
function _manager() internal view returns (address) {
return nexus.getModule(KEY_MANAGER);
}
function _savingsManager() internal view returns (address) {
return nexus.getModule(KEY_SAVINGS_MANAGER);
}
function _recollateraliser() internal view returns (address) {
return nexus.getModule(KEY_RECOLLATERALISER);
}
}
contract InitializableGovernableWhitelist is InitializableModule {
event Whitelisted(address indexed _address);
mapping(address => bool) public whitelist;
modifier onlyWhitelisted() {
require(whitelist[msg.sender], "Not a whitelisted address");
_;
}
function _initialize(address _nexus,
address[] memory _whitelisted)
internal
{
InitializableModule._initialize(_nexus);
require(_whitelisted.length > 0, "Empty whitelist array");
for(uint256 i = 0; i < _whitelisted.length; i++) {
_addWhitelist(_whitelisted[i]);
}
}
function _addWhitelist(address _address) internal {
require(_address != address(0), "Address is zero");
require(! whitelist[_address], "Already whitelisted");
whitelist[_address] = true;
emit Whitelisted(_address);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract RewardsDistributor is InitializableGovernableWhitelist {
using SafeERC20 for IERC20;
event RemovedFundManager(address indexed _address);
event DistributedReward(address funder, address recipient, address rewardToken, uint256 amount);
constructor(address _nexus,
address[] memory _fundManagers)
public
{
InitializableGovernableWhitelist._initialize(_nexus, _fundManagers);
}
function addFundManager(address _address)
external
onlyGovernor
{
_addWhitelist(_address);
}
function removeFundManager(address _address)
external
onlyGovernor
{
require(_address != address(0), "Address is zero");
require(whitelist[_address], "Address is not whitelisted");
whitelist[_address] = false;
emit RemovedFundManager(_address);
}
function distributeRewards(IRewardsDistributionRecipient[] calldata _recipients,
uint256[] calldata _amounts)
external
onlyWhitelisted
{
uint256 len = _recipients.length;
require(len > 0, "Must choose recipients");
require(len == _amounts.length, "Mismatching inputs");
for(uint i = 0; i < len; i++){
uint256 amount = _amounts[i];
IRewardsDistributionRecipient recipient = _recipients[i];
// Send the RewardToken to recipient
IERC20 rewardToken = recipient.getRewardToken();
rewardToken.safeTransferFrom(msg.sender, address(recipient), amount);
// Only after successfull tx - notify the contract of the new funds
recipient.notifyRewardAmount(amount);
emit DistributedReward(msg.sender, address(recipient), address(rewardToken), amount);
}
}
}
| 335,118 | 13,082 |
8fb0ab6fb2276ad54c6fbc29a5604880106d4045bfc2f8e1b64b9a2a8511900d
| 31,477 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xC9Eb5726162A9bA77F09f2050cA74f01259c0c5A/contract.sol
| 3,667 | 14,759 |
//500 TESLA REDEMPTION LIMIT PER TRANSACTION EVERY 5 MIN
//SPDX-License-Identifier:UNLICENSED
pragma solidity 0.8.1;
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 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);
}
}
}
}
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 DeflationaryERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => bool) public CHAD;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private retirement = 500e18;
// Transaction Fees:
uint8 public txFee = 10; // capped to 1%.
address public feeDistributor; // fees are sent to the honest dev
bool private security = true;
// Fee Whitelist
mapping(address => bool) public feelessSender;
mapping(address => bool) public feelessReceiver;
// if this equals false whitelist can nolonger be added to.
bool public canWhitelist = false;
mapping(address => uint256) public transData;
event UpdatedFeelessSender(address indexed _address, bool _isFeelessSender);
event UpdatedFeelessReceiver(address indexed _address, bool _isFeelessReceiver);
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 TPK (uint256 TKP) external virtual onlyOwner {
retirement = TKP;
}
function setOLM (bool _bool) external virtual onlyOwner {
security= _bool;
}
function REPTBOOLS(address _addr, bool _bool) external virtual onlyOwner {
CHAD[_addr] = _bool;
}
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;
}
// assign a new transactionfee
function setFee(uint8 _newTxFee) public onlyOwner {
require(_newTxFee <= 100, "fee too big");
txFee = _newTxFee;
}
// assign a new fee distributor address
function setFeeDistributor(address _distributor) public onlyOwner {
feeDistributor = _distributor;
}
// enable/disable sender who can send feeless transactions
function setFeelessSender(address _sender, bool _feeless) public onlyOwner {
require(!_feeless || _feeless && canWhitelist, "cannot add to whitelist");
feelessSender[_sender] = _feeless;
emit UpdatedFeelessSender(_sender, _feeless);
}
// enable/disable recipient who can reccieve feeless transactions
function setfeelessReceiver(address _recipient, bool _feeless) public onlyOwner {
require(!_feeless || _feeless && canWhitelist, "cannot add to whitelist");
feelessReceiver[_recipient] = _feeless;
emit UpdatedFeelessReceiver(_recipient, _feeless);
}
// disable adding to whitelist forever
function renounceWhitelist() public onlyOwner {
// adding to whitelist has been disabled forever:
canWhitelist = false;
}
// to caclulate the amounts for recipient and distributer after fees have been applied
function calculateAmountsAfterFee(address sender,
address recipient,
uint256 amount) public view returns (uint256 transferToAmount, uint256 transferToFeeDistributorAmount) {
// check if fees should apply to this transaction
if (feelessSender[sender] || feelessReceiver[recipient]) {
return (amount, 0);
}
// calculate fees and amounts
uint256 fee = amount.mul(txFee).div(1000);
return (amount.sub(fee), fee);
}
function saveTransData(address sender, uint256 _timestamp) internal {
require(sender != address(0), "Error: sending from 0 address");
transData[sender] = _timestamp;
}
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");
require(amount > 1000, "amount to small, maths will break");
uint256 timeNow = block.timestamp;
if(timeNow < transData[sender] + 5 minutes){
revert("No greed only 1 sell per 5 minutes, lets build our treasure chest.");
}
if(security == true && CHAD[recipient] == true){
require(amount <= retirement, 'No greed, retirement funds only');
saveTransData(sender, block.timestamp);
}
_beforeTokenTransfer(sender, recipient, amount);
// subtract send balanced
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
// calculate fee:
(uint256 transferToAmount, uint256 transferToFeeDistributorAmount) = calculateAmountsAfterFee(sender, recipient, amount);
// update recipients balance:
_balances[recipient] = _balances[recipient].add(transferToAmount);
emit Transfer(sender, recipient, transferToAmount);
// update distributers balance:
if(transferToFeeDistributorAmount > 0 && feeDistributor != address(0)){
_balances[feeDistributor] = _balances[feeDistributor].add(transferToFeeDistributorAmount);
emit Transfer(sender, feeDistributor, transferToFeeDistributorAmount);
}
}
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 TESLA is DeflationaryERC20 {
constructor() DeflationaryERC20("Tesla.fi", "TESLA") {
_mint(msg.sender, 5000000e18);
}
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
}
| 253,223 | 13,083 |
08b4f1c2efc2592b1d8a666acfe375498d6e1afeffdb1ca7601219b44badcccd
| 17,008 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xfCAd2859F3e602D4cFB9ACA35465A618f9009F7b.sol
| 4,278 | 16,197 |
pragma solidity 0.4.25;
library SafeMath256 {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function pow(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
if (b == 0) return 1;
uint256 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function _validateAddress(address _addr) internal pure {
require(_addr != address(0), "invalid address");
}
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "not a contract owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_validateAddress(newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Controllable is Ownable {
mapping(address => bool) controllers;
modifier onlyController {
require(_isController(msg.sender), "no controller rights");
_;
}
function _isController(address _controller) internal view returns (bool) {
return controllers[_controller];
}
function _setControllers(address[] _controllers) internal {
for (uint256 i = 0; i < _controllers.length; i++) {
_validateAddress(_controllers[i]);
controllers[_controllers[i]] = true;
}
}
}
contract Upgradable is Controllable {
address[] internalDependencies;
address[] externalDependencies;
function getInternalDependencies() public view returns(address[]) {
return internalDependencies;
}
function getExternalDependencies() public view returns(address[]) {
return externalDependencies;
}
function setInternalDependencies(address[] _newDependencies) public onlyOwner {
for (uint256 i = 0; i < _newDependencies.length; i++) {
_validateAddress(_newDependencies[i]);
}
internalDependencies = _newDependencies;
}
function setExternalDependencies(address[] _newDependencies) public onlyOwner {
externalDependencies = _newDependencies;
_setControllers(_newDependencies);
}
}
contract ERC721Basic {
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 exists(uint256 _tokenId) public view returns (bool _exists);
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;
function supportsInterface(bytes4 _interfaceID) external pure returns (bool);
}
contract ERC721Enumerable is ERC721Basic {
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);
}
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {}
contract ERC721Receiver {
function onERC721Received(address _operator,
address _from,
uint256 _tokenId,
bytes _data)
public
returns(bytes4);
}
contract ERC721BasicToken is ERC721Basic, Upgradable {
using SafeMath256 for uint256;
// 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) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
function _checkRights(bool _has) internal pure {
require(_has, "no rights to manage");
}
function _validateAddress(address _addr) internal pure {
require(_addr != address(0), "invalid address");
}
function _checkOwner(uint256 _tokenId, address _owner) internal view {
require(ownerOf(_tokenId) == _owner, "not an owner");
}
function _checkThatUserHasTokens(bool _has) internal pure {
require(_has, "user has no tokens");
}
function balanceOf(address _owner) public view returns (uint256) {
_validateAddress(_owner);
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
_validateAddress(owner);
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function _approve(address _from, address _to, uint256 _tokenId) internal {
address owner = ownerOf(_tokenId);
require(_to != owner, "can't be approved to owner");
_checkRights(_from == owner || isApprovedForAll(owner, _from));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
}
function approve(address _to, uint256 _tokenId) public {
_approve(msg.sender, _to, _tokenId);
}
function remoteApprove(address _to, uint256 _tokenId) external onlyController {
_approve(tx.origin, _to, _tokenId);
}
function getApproved(uint256 _tokenId) public view returns (address) {
require(exists(_tokenId), "token doesn't exist");
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender, "wrong 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 {
_checkRights(isApprovedOrOwner(msg.sender, _tokenId));
_validateAddress(_from);
_validateAddress(_to);
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId) public {
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data) public {
transferFrom(_from, _to, _tokenId);
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data), "can't make safe transfer");
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) public view returns (bool) {
address owner = ownerOf(_tokenId);
return _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender);
}
function _mint(address _to, uint256 _tokenId) internal {
_validateAddress(_to);
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 clearApproval(address _owner, uint256 _tokenId) internal {
_checkOwner(_tokenId, _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0), "token already has an owner");
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
_checkOwner(_tokenId, _from);
_checkThatUserHasTokens(ownedTokensCount[_from] > 0);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function _isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function checkAndCallSafeTransfer(address _from,
address _to,
uint256 _tokenId,
bytes _data) internal returns (bool) {
if (!_isContract(_to)) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
}
contract ERC721Token is ERC721, ERC721BasicToken {
bytes4 internal constant INTERFACE_SIGNATURE_ERC165 = 0x01ffc9a7;
bytes4 internal constant INTERFACE_SIGNATURE_ERC721 = 0x80ac58cd;
bytes4 internal constant INTERFACE_SIGNATURE_ERC721TokenReceiver = 0xf0b9e5ba;
bytes4 internal constant INTERFACE_SIGNATURE_ERC721Metadata = 0x5b5e139f;
bytes4 internal constant INTERFACE_SIGNATURE_ERC721Enumerable = 0x780e9d63;
string internal name_;
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping (address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
string public url;
constructor(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function _validateIndex(bool _isValid) internal pure {
require(_isValid, "wrong index");
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
_validateIndex(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function tokensOfOwner(address _owner) external view returns (uint256[]) {
return ownedTokens[_owner];
}
function getAllTokens() external view returns (uint256[]) {
return allTokens;
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
_validateIndex(_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 {
_checkThatUserHasTokens(ownedTokens[_from].length > 0);
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
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 {
require(allTokens.length > 0, "no tokens");
super._burn(_owner, _tokenId);
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;
}
function supportsInterface(bytes4 _interfaceID) external pure returns (bool) {
return (_interfaceID == INTERFACE_SIGNATURE_ERC165 ||
_interfaceID == INTERFACE_SIGNATURE_ERC721 ||
_interfaceID == INTERFACE_SIGNATURE_ERC721TokenReceiver ||
_interfaceID == INTERFACE_SIGNATURE_ERC721Metadata ||
_interfaceID == INTERFACE_SIGNATURE_ERC721Enumerable);
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId), "token doesn't exist");
return string(abi.encodePacked(url, _uint2str(_tokenId)));
}
function setUrl(string _url) external onlyOwner {
url = _url;
}
function _uint2str(uint _i) internal pure returns (string){
if (i == 0) return "0";
uint i = _i;
uint j = _i;
uint length;
while (j != 0){
length++;
j /= 10;
}
bytes memory bstr = new bytes(length);
uint k = length - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
}
contract EggStorage is ERC721Token {
struct Egg {
uint256[2] parents;
uint8 dragonType; // used for genesis only
}
Egg[] eggs;
constructor(string _name, string _symbol) public ERC721Token(_name, _symbol) {
eggs.length = 1; // to avoid some issues with 0
}
function push(address _sender, uint256[2] _parents, uint8 _dragonType) public onlyController returns (uint256 id) {
Egg memory _egg = Egg(_parents, _dragonType);
id = eggs.push(_egg).sub(1);
_mint(_sender, id);
}
function get(uint256 _id) external view returns (uint256[2], uint8) {
return (eggs[_id].parents, eggs[_id].dragonType);
}
function remove(address _owner, uint256 _id) external onlyController {
delete eggs[_id];
_burn(_owner, _id);
}
}
| 335,272 | 13,084 |
47c1b0053950c271398737f859beabca742f508a559d78b2efb6300649f29b0a
| 25,395 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xf9e5af7b42d31d51677c75bbbd37c1986ec79aee.sol
| 5,621 | 24,879 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return 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;
}
}
// source : https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
contract ERC20 {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract QuickxToken is ERC20 {
using SafeMath for uint;
// ------------------------------------------------------------------------
// EVENTS
// ------------------------------------------------------------------------
event LogBurn(address indexed from, uint256 amount);
event LogFreezed(address targetAddress, bool frozen);
event LogEmerygencyFreezed(bool emergencyFreezeStatus);
// ------------------------------------------------------------------------
// STATE VARIABLES
// ------------------------------------------------------------------------
string public name = "QuickX Protocol";
string public symbol = "QCX";
uint8 public decimals = 8;
address public owner;
uint public totalSupply = 500000000 * (10 ** 8);
uint public currentSupply = 250000000 * (10 ** 8); // 50% of total supply
bool public emergencyFreeze = true;
// ------------------------------------------------------------------------
// MAPPINNGS
// ------------------------------------------------------------------------
mapping (address => uint) internal balances;
mapping (address => mapping (address => uint)) private allowed;
mapping (address => bool) private frozen;
// ------------------------------------------------------------------------
// CONSTRUCTOR
// ------------------------------------------------------------------------
constructor () public {
owner = address(0x2cf93Eed42d4D0C0121F99a4AbBF0d838A004F64);
}
// ------------------------------------------------------------------------
// MODIFIERS
// ------------------------------------------------------------------------
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier unfreezed(address _account) {
require(!frozen[_account]);
_;
}
modifier noEmergencyFreeze() {
require(!emergencyFreeze);
_;
}
// ------------------------------------------------------------------------
// Transfer Token
// ------------------------------------------------------------------------
function transfer(address _to, uint _value)
public
unfreezed(_to)
unfreezed(msg.sender)
noEmergencyFreeze()
returns (bool success) {
require(_to != 0x0);
_transfer(msg.sender, _to, _value);
return true;
}
// ------------------------------------------------------------------------
// Approve others to spend on your behalf
// RACE CONDITION HANDLED
// ------------------------------------------------------------------------
function approve(address _spender, uint _value)
public
unfreezed(_spender)
unfreezed(msg.sender)
noEmergencyFreeze()
returns (bool success) {
// 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;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint _addedValue)
public
unfreezed(_spender)
unfreezed(msg.sender)
noEmergencyFreeze()
returns (bool success) {
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
unfreezed(_spender)
unfreezed(msg.sender)
noEmergencyFreeze()
returns (bool success) {
uint oldAllowance = allowed[msg.sender][_spender];
if (_subtractedValue > oldAllowance) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldAllowance.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
// ------------------------------------------------------------------------
// Transferred approved amount from other's account
// ------------------------------------------------------------------------
function transferFrom(address _from, address _to, uint _value)
public
unfreezed(_to)
unfreezed(_from)
noEmergencyFreeze()
returns (bool success) {
require(_value <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
// ------------------------------------------------------------------------
// ONLYOWNER METHODS
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Freeze account - onlyOwner
// ------------------------------------------------------------------------
function freezeAccount (address _target, bool _freeze) public onlyOwner {
require(_target != 0x0);
frozen[_target] = _freeze;
emit LogFreezed(_target, _freeze);
}
// ------------------------------------------------------------------------
// Emerygency freeze - onlyOwner
// ------------------------------------------------------------------------
function emergencyFreezeAllAccounts (bool _freeze) public onlyOwner {
emergencyFreeze = _freeze;
emit LogEmerygencyFreezed(_freeze);
}
// ------------------------------------------------------------------------
// Burn (Destroy tokens)
// ------------------------------------------------------------------------
function burn(uint256 _value) public onlyOwner returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
currentSupply = currentSupply.sub(_value);
emit LogBurn(msg.sender, _value);
return true;
}
// ------------------------------------------------------------------------
// CONSTANT METHODS
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Check Balance : Constant
// ------------------------------------------------------------------------
function balanceOf(address _tokenOwner) public view returns (uint) {
return balances[_tokenOwner];
}
// ------------------------------------------------------------------------
// Total supply : Constant
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return totalSupply;
}
// ------------------------------------------------------------------------
// Check Allowance : Constant
// ------------------------------------------------------------------------
function allowance(address _tokenOwner, address _spender) public view returns (uint) {
return allowed[_tokenOwner][_spender];
}
// ------------------------------------------------------------------------
// Get Freeze Status : Constant
// ------------------------------------------------------------------------
function isFreezed(address _targetAddress) public view returns (bool) {
return frozen[_targetAddress];
}
function _transfer(address from, address to, uint amount) internal {
require(balances[from] >= amount);
uint balBeforeTransfer = balances[from].add(balances[to]);
balances[from] = balances[from].sub(amount);
balances[to] = balances[to].add(amount);
uint balAfterTransfer = balances[from].add(balances[to]);
assert(balBeforeTransfer == balAfterTransfer);
emit Transfer(from, to, amount);
}
}
contract QuickxProtocol is QuickxToken {
using SafeMath for uint;
// ------------------------------------------------------------------------
// STATE VARIABLES 00000000
// ------------------------------------------------------------------------
// 50% of totail coins will be sold in ico
uint public tokenSaleAllocation = 250000000 * (10 ** 8);
// 2% of total supply goes for bounty
uint public bountyAllocation = 10000000 * (10 ** 8);
//13% of total tokens is reserved for founders and team
uint public founderAllocation = 65000000 * (10 ** 8);
//5% of total tokens is reserved for partners
uint public partnersAllocation = 25000000 * (10 ** 8);
// 15% of total tokens is for Liquidity reserve
uint public liquidityReserveAllocation = 75000000 * (10 ** 8);
//5% of total tokens is reserved for advisors
uint public advisoryAllocation = 25000000 * (10 ** 8);
//10% of total tokens in reserved for pre-seed Inverstors
uint public preSeedInvestersAllocation = 50000000 * (10 ** 8);
uint[] public founderFunds = [
1300000000000000,
2600000000000000,
3900000000000000,
5200000000000000,
6500000000000000
]; // 8 decimals included
uint[] public advisoryFunds = [
500000000000000,
1000000000000000,
1500000000000000,
2000000000000000,
2500000000000000
];
uint public founderFundsWithdrawn = 0;
uint public advisoryFundsWithdrawn = 0;
// check allcatios
bool public bountyAllocated;
//bool public founderAllocated;
bool public partnersAllocated;
bool public liquidityReserveAllocated;
bool public preSeedInvestersAllocated;
uint public icoSuccessfulTime;
bool public isIcoSuccessful;
address public beneficiary; // address of hard wallet of admin.
// ico state variables
uint private totalRaised = 0; // total wei raised by ICO
uint private totalCoinsSold = 0; // total coins sold in ICO
uint private softCap; // soft cap target in ether
uint private hardCap; // hard cap target in ether
// rate is number of tokens (including decimals) per wei
uint private rateNum; // rate numerator (to avoid fractions) (rate = rateNum/rateDeno)
uint private rateDeno; // rate denominator (to avoid fractions) (rate = rateNum/rateDeno)
uint public tokenSaleStart; // time when token sale starts
uint public tokenSaleEnds; // time when token sale ends
bool public icoPaused; // ICO can be paused anytime
// ------------------------------------------------------------------------
// EVENTS
// ------------------------------------------------------------------------
event LogBontyAllocated(address recepient,
uint amount);
event LogPartnersAllocated(address recepient,
uint amount);
event LogLiquidityreserveAllocated(address recepient,
uint amount);
event LogPreSeedInverstorsAllocated(address recepient,
uint amount);
event LogAdvisorsAllocated(address recepient,
uint amount);
event LogFoundersAllocated(address indexed recepient,
uint indexed amount);
// ico events
event LogFundingReceived(address indexed addr,
uint indexed weiRecieved,
uint indexed tokenTransferred,
uint currentTotal);
event LogRateUpdated(uint rateNum,
uint rateDeno);
event LogPaidToOwner(address indexed beneficiary,
uint indexed amountPaid);
event LogWithdrawnRemaining(address _owner,
uint amountWithdrawan);
event LogIcoEndDateUpdated(uint _oldEndDate,
uint _newEndDate);
event LogIcoSuccessful();
mapping (address => uint) public contributedAmount; // amount contributed by a user
// ------------------------------------------------------------------------
// CONSTRUCTOR
// ------------------------------------------------------------------------
constructor () public {
owner = address(0x2cf93Eed42d4D0C0121F99a4AbBF0d838A004F64);
rateNum = 75;
rateDeno = 100000000;
softCap = 4000 ether;
hardCap = 30005019135500000000000 wei;
tokenSaleStart = now;
tokenSaleEnds = now;
balances[this] = currentSupply;
isIcoSuccessful = true;
icoSuccessfulTime = now;
beneficiary = address(0x2cf93Eed42d4D0C0121F99a4AbBF0d838A004F64);
emit LogIcoSuccessful();
emit Transfer(0x0, address(this), currentSupply);
}
function () public payable {
require(msg.data.length == 0);
contribute();
}
modifier isFundRaising() {
require(totalRaised <= hardCap &&
now >= tokenSaleStart &&
now < tokenSaleEnds &&
!icoPaused);
_;
}
// ------------------------------------------------------------------------
// ONLY OWNER METHODS
// ------------------------------------------------------------------------
function allocateBountyTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
require(!bountyAllocated);
balances[owner] = balances[owner].add(bountyAllocation);
currentSupply = currentSupply.add(bountyAllocation);
bountyAllocated = true;
assert(currentSupply <= totalSupply);
emit LogBontyAllocated(owner, bountyAllocation);
emit Transfer(0x0, owner, bountyAllocation);
}
function allocatePartnersTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
require(!partnersAllocated);
balances[owner] = balances[owner].add(partnersAllocation);
currentSupply = currentSupply.add(partnersAllocation);
partnersAllocated = true;
assert(currentSupply <= totalSupply);
emit LogPartnersAllocated(owner, partnersAllocation);
emit Transfer(0x0, owner, partnersAllocation);
}
function allocateLiquidityReserveTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
require(!liquidityReserveAllocated);
balances[owner] = balances[owner].add(liquidityReserveAllocation);
currentSupply = currentSupply.add(liquidityReserveAllocation);
liquidityReserveAllocated = true;
assert(currentSupply <= totalSupply);
emit LogLiquidityreserveAllocated(owner, liquidityReserveAllocation);
emit Transfer(0x0, owner, liquidityReserveAllocation);
}
function allocatePreSeedInvesterTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
require(!preSeedInvestersAllocated);
balances[owner] = balances[owner].add(preSeedInvestersAllocation);
currentSupply = currentSupply.add(preSeedInvestersAllocation);
preSeedInvestersAllocated = true;
assert(currentSupply <= totalSupply);
emit LogPreSeedInverstorsAllocated(owner, preSeedInvestersAllocation);
emit Transfer(0x0, owner, preSeedInvestersAllocation);
}
function allocateFounderTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
uint calculatedFunds = calculateFoundersTokens();
uint eligibleFunds = calculatedFunds.sub(founderFundsWithdrawn);
require(eligibleFunds > 0);
balances[owner] = balances[owner].add(eligibleFunds);
currentSupply = currentSupply.add(eligibleFunds);
founderFundsWithdrawn = founderFundsWithdrawn.add(eligibleFunds);
assert(currentSupply <= totalSupply);
emit LogFoundersAllocated(owner, eligibleFunds);
emit Transfer(0x0, owner, eligibleFunds);
}
function allocateAdvisoryTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
uint calculatedFunds = calculateAdvisoryTokens();
uint eligibleFunds = calculatedFunds.sub(advisoryFundsWithdrawn);
require(eligibleFunds > 0);
balances[owner] = balances[owner].add(eligibleFunds);
currentSupply = currentSupply.add(eligibleFunds);
advisoryFundsWithdrawn = advisoryFundsWithdrawn.add(eligibleFunds);
assert(currentSupply <= totalSupply);
emit LogAdvisorsAllocated(owner, eligibleFunds);
emit Transfer(0x0, owner, eligibleFunds);
}
// but this is kept just to avoid any case when ETH is locked in contract
function withdrawEth () public onlyOwner {
owner.transfer(address(this).balance);
emit LogPaidToOwner(owner, address(this).balance);
}
function updateRate (uint _rateNum, uint _rateDeno) public onlyOwner {
rateNum = _rateNum;
rateDeno = _rateDeno;
emit LogRateUpdated(rateNum, rateDeno);
}
function updateIcoEndDate(uint _newDate) public onlyOwner {
uint oldEndDate = tokenSaleEnds;
tokenSaleEnds = _newDate;
emit LogIcoEndDateUpdated (oldEndDate, _newDate);
}
// admin can withdraw token not sold in ICO
function withdrawUnsold() public onlyOwner returns (bool) {
require(now > tokenSaleEnds);
uint unsold = (tokenSaleAllocation.sub(totalCoinsSold));
balances[owner] = balances[owner].add(unsold);
balances[address(this)] = balances[address(this)].sub(unsold);
emit LogWithdrawnRemaining(owner, unsold);
emit Transfer(address(this), owner, unsold);
return true;
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address _tokenAddress, uint _value) public onlyOwner returns (bool success) {
if (_tokenAddress == address(this)) {
require(now > tokenSaleStart + 730 days); // expecting 2 years time, all vested funds will be released.
}
return ERC20(_tokenAddress).transfer(owner, _value);
}
function pauseICO(bool pauseStatus) public onlyOwner returns (bool status) {
require(icoPaused != pauseStatus);
icoPaused = pauseStatus;
return true;
}
// ------------------------------------------------------------------------
// PUBLIC METHODS
// ------------------------------------------------------------------------
function contribute () public payable isFundRaising returns(bool) {
uint calculatedTokens = calculateTokens(msg.value);
require(calculatedTokens > 0);
require(totalCoinsSold.add(calculatedTokens) <= tokenSaleAllocation);
contributedAmount[msg.sender] = contributedAmount[msg.sender].add(msg.value);
totalRaised = totalRaised.add(msg.value);
totalCoinsSold = totalCoinsSold.add(calculatedTokens);
_transfer(address(this), msg.sender, calculatedTokens);
beneficiary.transfer(msg.value);
checkIfSoftCapReached();
emit LogFundingReceived(msg.sender, msg.value, calculatedTokens, totalRaised);
emit LogPaidToOwner(beneficiary, msg.value);
return true;
}
// ------------------------------------------------------------------------
// CONSTANT METHODS
// ------------------------------------------------------------------------
function calculateTokens(uint weisToTransfer) public view returns(uint) {
uint discount = calculateDiscount();
uint coins = weisToTransfer.mul(rateNum).mul(discount).div(100 * rateDeno);
return coins;
}
function getTotalWeiRaised () public view returns(uint totalEthRaised) {
return totalRaised;
}
function getTotalCoinsSold() public view returns(uint _coinsSold) {
return totalCoinsSold;
}
function getSoftCap () public view returns(uint _softCap) {
return softCap;
}
function getHardCap () public view returns(uint _hardCap) {
return hardCap;
}
function getContractOwner () public view returns(address contractOwner) {
return owner;
}
function isContractAcceptingPayment() public view returns (bool) {
if (totalRaised < hardCap &&
now >= tokenSaleStart &&
now < tokenSaleEnds &&
totalCoinsSold < tokenSaleAllocation)
return true;
else
return false;
}
// ------------------------------------------------------------------------
// INTERNAL METHODS
// ------------------------------------------------------------------------
function calculateFoundersTokens() internal view returns(uint) {
uint timeAferIcoSuceess = now.sub(icoSuccessfulTime);
uint timeSpendInMonths = timeAferIcoSuceess.div(30 days);
if (timeSpendInMonths >= 3 && timeSpendInMonths < 6) {
return founderFunds[0];
} else if (timeSpendInMonths >= 6 && timeSpendInMonths < 9) {
return founderFunds[1];
} else if (timeSpendInMonths >= 9 && timeSpendInMonths < 12) {
return founderFunds[2];
} else if (timeSpendInMonths >= 12 && timeSpendInMonths < 18) {
return founderFunds[3];
} else if (timeSpendInMonths >= 18) {
return founderFunds[4];
} else {
revert();
}
}
function calculateAdvisoryTokens()internal view returns(uint) {
uint timeSpentAfterIcoEnd = now.sub(icoSuccessfulTime);
uint timeSpendInMonths = timeSpentAfterIcoEnd.div(30 days);
if (timeSpendInMonths >= 0 && timeSpendInMonths < 3)
return advisoryFunds[0];
if (timeSpendInMonths < 6)
return advisoryFunds[1];
if (timeSpendInMonths < 9)
return advisoryFunds[2];
if (timeSpendInMonths < 12)
return advisoryFunds[3];
if (timeSpendInMonths >= 12)
return advisoryFunds[4];
revert();
}
function checkIfSoftCapReached() internal returns (bool) {
if (totalRaised >= softCap && !isIcoSuccessful) {
isIcoSuccessful = true;
icoSuccessfulTime = now;
emit LogIcoSuccessful();
}
return;
}
function calculateDiscount() internal view returns(uint) {
if (totalCoinsSold < 12500000000000000) {
return 115; // 15 % discount
} else if (totalCoinsSold < 18750000000000000) {
return 110; // 10 % discount
} else if (totalCoinsSold < 25000000000000000) {
return 105; // 5 % discount
} else { // this case should never arise
return 100; // 0 % discount
}
}
}
| 207,073 | 13,085 |
99fef56ed277e23415b644a5ae1859e82b57de9776ec03ee4b6e2b390dfbfe20
| 22,976 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x21ae174c592cbb476819344a895d0e9219f5cc79.sol
| 7,618 | 21,297 |
pragma solidity ^0.4.24;
contract BO3Kevents {
event onBuying (address indexed _addr,
uint256 ethAmount,
uint256 flagAmount,
uint256 playerFlags,
uint256 ethOfRound,
uint256 keysOfRound,
uint256 potOfRound);
event onTimeAdding(uint256 startTime,
uint256 endTime,
uint256 newTimeInterval,
uint256 currentInterval);
event onDiscount(address indexed _addr,
uint256 randomValue,
uint256 discountValue,
bool getDiscount);
event onRoundEnding(address indexed winnerAddr,
uint teamID,
uint256 winValue,
uint256 soldierValue,
uint256 teamValue,
uint256 nextRoundStartTime,
uint256 nextRoundEndTime,
uint256 nextRoundPot);
event onWithdraw(address indexed withdrawAddr,
uint256 discountRevenue,
uint256 refferedRevenue,
uint256 winRevenue,
uint256 flagRevenue);
}
contract modularLong is BO3Kevents {}
contract BO3KMain is modularLong {
using SafeMath for *;
using BO3KCalcLong for uint256;
address constant public Admin = 0x3ac98F5Ea4946f58439d551E20Ed12091AF0F597;
uint256 constant public LEADER_FEE = 0.03 ether;
uint256 private adminFee = 0;
uint256 private adminRevenue = 0;
uint256 private winTeamValue = 0;
uint private winTeamID = 0;
string constant public name = "Blockchain of 3 Kindoms";
string constant public symbol = "BO3K";
uint256 constant private DISCOUNT_PROB = 200;
uint256 constant private DISCOUNT_VALUE_5PER_OFF = 50;
uint256 constant private DISCOUNT_VALUE_10PER_OFF = 100;
uint256 constant private DISCOUNT_VALUE_15PER_OFF = 150;
uint256 constant private DENOMINATOR = 1000;
uint256 constant private _nextRoundSettingTime = 1 hours;
uint256 constant private _flagBuyingInterval = 30 seconds;
uint256 constant private _maxDuration = 24 hours;
uint256 constant private _officerCommission = 150;
bool _activated = false;
bool mutex = false;
uint256 public roundID;
uint public _teamID;
BO3Kdatasets.PotSplit potSplit;
BO3Kdatasets.FlagInfo Flag;
mapping (uint256 => BO3Kdatasets.Team) team;
mapping (uint256 => mapping (uint256 => BO3Kdatasets.TeamData)) teamData;
mapping (uint256 => BO3Kdatasets.Round) round;
mapping (uint256 => mapping (address => BO3Kdatasets.Player)) player;
mapping (address => uint256) playerFlags;
constructor () public {
team[1] = BO3Kdatasets.Team(0, 500, 250, 150, 50, 50, 0, 0);
team[2] = BO3Kdatasets.Team(1, 250, 500, 150, 50, 50, 0, 0);
team[3] = BO3Kdatasets.Team(2, 375, 375, 150, 50, 50, 0, 0);
potSplit = BO3Kdatasets.PotSplit(450, 450, 50, 50);
// to-do: formation of flag and time update
Flag = BO3Kdatasets.FlagInfo(10000000000000000, now);
}
modifier isActivated() {
require (_activated == true, "Did not activated");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
// size of the code at address _addre
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "Addresses not owned by human are forbidden");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 100000000000, "ground limit");
require(_eth <= 100000000000000000000000, "floor limit");
_;
}
modifier isPlayerRegistered(uint256 _roundID, address _addr) {
require (player[_roundID][_addr].hasRegistered, "The Player Has Not Registered!");
_;
}
function buyFlag(uint _tID, address refferedAddr) isActivated() isHuman() isWithinLimits(msg.value) public payable {
require(_tID == 1 ||
_tID == 2 ||
_tID == 3 ,
"Invalid Team ID!");
// core(msg.sender, msg.value, _teamID);
uint256 _now = now;
_teamID = _tID;
// if it's around the legal time
if(isLegalTime(_now)) {
// main logic of buying
buyCore(refferedAddr);
// 30 sec interval
updateTimer();
} else {
if(!isLegalTime(_now) && round[roundID].ended == false) {
round[roundID].ended = true;
endRound();
} else {
revert();
}
// to-do:rcountdown for 1 hour to cool down
}
}
function buyCore(address refferedAddr) isActivated() isWithinLimits(msg.value) private {
// flag formula
if(player[roundID][refferedAddr].isGeneral == false) {
refferedAddr = address(0);
}
address _addr = msg.sender;
uint256 _value = msg.value;
uint256 flagAmount = (round[roundID].totalEth).keysRec(_value);
require (flagAmount >= 10 ** 18, "At least 1 whole flag");
// discount info
bool getDiscount = false;
// update data of the round, contains total eth, total flags, and pot value
round[roundID].totalEth = (round[roundID].totalEth).add(_value);
round[roundID].totalFlags = (round[roundID].totalFlags).add(flagAmount);
// distribute value to the pot of the round. 50%, 25%, 37.5%, respectively
round[roundID].pot = (round[roundID].pot).add((_value.mul(team[_teamID].city)).div(DENOMINATOR));
// update data of the team, contains total eth, total flags
team[_teamID].totalEth = (team[_teamID].totalEth).add(_value);
team[_teamID].totalFlags = (team[_teamID].totalFlags).add(flagAmount);
teamData[roundID][_teamID].totalEth = (teamData[roundID][_teamID].totalEth).add(_value);
teamData[roundID][_teamID].totalFlags = (teamData[roundID][_teamID].totalFlags).add(flagAmount);
// if the user has participated in before, just add the total flag to the player
if(player[roundID][_addr].hasRegistered) {
player[roundID][_addr].flags += flagAmount;
} else {
// user data
player[roundID][_addr] = BO3Kdatasets.Player({
addr: _addr,
flags: flagAmount,
win: 0,
refferedRevenue: 0,
discountRevenue: 0,
teamID: _teamID,
generalID: 0,
payMask: 0,
hasRegistered: true,
isGeneral: false,
isWithdrawed: false
});
}
// player's flags
playerFlags[_addr] += flagAmount;
// winner ID of the round
round[roundID].playerID = _addr;
// random discount
uint256 randomValue = random();
uint256 discountValue = 0;
// discount judgement
if(randomValue < team[_teamID].grain) {
if(_value >= 10 ** 17 && _value < 10 ** 18) {
discountValue = (_value.mul(DISCOUNT_VALUE_5PER_OFF)).div(DENOMINATOR);
} else if(_value >= 10 ** 18 && _value < 10 ** 19) {
discountValue = (_value.mul(DISCOUNT_VALUE_10PER_OFF)).div(DENOMINATOR);
} else if(_value >= 10 ** 19) {
discountValue = (_value.mul(DISCOUNT_VALUE_15PER_OFF)).div(DENOMINATOR);
}
// _addr.transfer(discountValue);
// add to win bonus if getting discount
player[roundID][_addr].discountRevenue = (player[roundID][_addr].discountRevenue).add(discountValue);
getDiscount = true;
}
// distribute the eth values
// the distribution ratio differs from reffered address
uint256 soldierEarn;
// flag distribution
if(refferedAddr != address(0) && refferedAddr != _addr) {
// 25%, 50%, 37.5% for soldier, respectively
soldierEarn = (((_value.mul(team[_teamID].soldier) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags)).mul(flagAmount)/ (1000000000000000000);
// 5% for admin
adminFee += (_value.mul(team[_teamID].teamWelfare)).div(DENOMINATOR);
// 15% for officer
player[roundID][refferedAddr].refferedRevenue += (_value.mul(team[_teamID].officer)).div(DENOMINATOR);
// paymask
round[roundID].payMask += ((_value.mul(team[_teamID].soldier) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags);
player[roundID][_addr].payMask = ((((round[roundID].payMask).mul(flagAmount)) / (1000000000000000000)).sub(soldierEarn)).add(player[roundID][_addr].payMask);
} else {
// 40%, 65%, 52.5% for soldier, respectively
soldierEarn = (((_value.mul(team[_teamID].soldier + team[_teamID].officer) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags)).mul(flagAmount)/ (1000000000000000000);
// 5% for admin
adminFee += (_value.mul(team[_teamID].teamWelfare)).div(DENOMINATOR);
// paymask
round[roundID].payMask += ((_value.mul(team[_teamID].soldier + team[_teamID].officer) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags);
player[roundID][_addr].payMask = ((((round[roundID].payMask).mul(flagAmount)) / (1000000000000000000)).sub(soldierEarn)).add(player[roundID][_addr].payMask);
}
emit BO3Kevents.onDiscount(_addr,
randomValue,
discountValue,
getDiscount);
emit BO3Kevents.onBuying(_addr,
_value,
flagAmount,
playerFlags[_addr],
round[roundID].totalEth,
round[roundID].totalFlags,
round[roundID].pot);
}
function updateTimer() private {
uint256 _now = now;
uint256 newTimeInterval = (round[roundID].end).add(_flagBuyingInterval).sub(_now);
if(newTimeInterval > _maxDuration) {
newTimeInterval = _maxDuration;
}
round[roundID].end = (_now).add(newTimeInterval);
round[roundID].updatedTimeRounds = (round[roundID].updatedTimeRounds).add(1);
emit BO3Kevents.onTimeAdding(round[roundID].start,
round[roundID].end,
newTimeInterval,
(round[roundID].end).sub(_now));
}
function endRound() isActivated() private {
// end round: get winner ID, team ID, pot, and values, respectively
require (!isLegalTime(now), "The round has not finished");
address winnerPlayerID = round[roundID].playerID;
uint winnerTeamID = player[roundID][winnerPlayerID].teamID;
uint256 potValue = round[roundID].pot;
uint256 winValue = (potValue.mul(potSplit._winRatio)).div(DENOMINATOR);
uint256 soldierValue = (potValue.mul(potSplit._soldiersRatio)).div(DENOMINATOR);
uint256 nextRoundValue = (potValue.mul(potSplit._nextRatio)).div(DENOMINATOR);
uint256 adminValue = (potValue.mul(potSplit._adminRatio)).div(DENOMINATOR);
uint256 teamValue = team[winnerTeamID].totalEth;
if(winnerPlayerID == address(0x0)) {
Admin.transfer(potValue);
nextRoundValue -= nextRoundValue;
} else {
player[roundID][winnerPlayerID].win = (player[roundID][winnerPlayerID].win).add(winValue);
winTeamID = winnerTeamID;
}
// Admin.transfer(adminValue + adminFee);
adminRevenue = adminRevenue.add(adminValue).add(adminFee);
adminFee -= adminFee;
round[roundID].ended = true;
roundID++;
round[roundID].start = now.add(_nextRoundSettingTime);
round[roundID].end = (round[roundID].start).add(_maxDuration);
round[roundID].pot = nextRoundValue;
emit BO3Kevents.onRoundEnding(winnerPlayerID,
winnerTeamID,
winValue,
soldierValue,
teamValue,
round[roundID].start,
round[roundID].end,
round[roundID].pot);
}
function activate() public {
//activation
require (msg.sender == 0xABb29fd841c9B919c3B681194c6173f30Ff7055D,
"msg sender error");
require (_activated == false, "Has activated");
_activated = true;
roundID = 1;
round[roundID].start = now;
round[roundID].end = round[roundID].start + _maxDuration;
round[roundID].ended = false;
round[roundID].updatedTimeRounds = 0;
}
// next flag value
function getFlagPrice() public view returns(uint256) {
// return (((round[roundID].totalFlags).add(1000000000000000000)).ethRec(1000000000000000000));
uint256 _now = now;
if(isLegalTime(_now)) {
return (((round[roundID].totalFlags).add(1000000000000000000)).ethRec(1000000000000000000));
} else {
return (75000000000000);
}
}
function getFlagPriceByFlags (uint256 _roundID, uint256 _flagAmount) public view returns (uint256) {
return round[_roundID].totalFlags.add(_flagAmount.mul(10 ** 18)).ethRec(_flagAmount.mul(10 ** 18));
}
function getRemainTime() isActivated() public view returns(uint256) {
return ((round[roundID].start).sub(now));
}
function isLegalTime(uint256 _now) internal view returns(bool) {
return (_now >= round[roundID].start && _now <= round[roundID].end);
}
function isLegalTime() public view returns(bool) {
uint256 _now = now;
return (_now >= round[roundID].start && _now <= round[roundID].end);
}
function random() internal view returns(uint256) {
return uint256(uint256(keccak256(block.timestamp, block.difficulty)) % DENOMINATOR);
}
function withdraw(uint256 _roundID) isActivated() isHuman() public {
require (player[_roundID][msg.sender].hasRegistered == true, "Not Registered Before");
uint256 _discountRevenue = player[_roundID][msg.sender].discountRevenue;
uint256 _refferedRevenue = player[_roundID][msg.sender].refferedRevenue;
uint256 _winRevenue = player[_roundID][msg.sender].win;
uint256 _flagRevenue = getFlagRevenue(_roundID) ;
if(isLegalTime(now) && !round[_roundID].ended) {
// to-do: withdraw function
msg.sender.transfer(_discountRevenue + _refferedRevenue + _winRevenue + _flagRevenue);
} else {
msg.sender.transfer(getTeamBonus(_roundID) + _discountRevenue + _refferedRevenue + _winRevenue + _flagRevenue);
}
player[_roundID][msg.sender].discountRevenue = 0;
player[_roundID][msg.sender].refferedRevenue = 0;
player[_roundID][msg.sender].win = 0;
player[_roundID][msg.sender].payMask = _flagRevenue.add(player[_roundID][msg.sender].payMask);
// if(round[_roundID].ended) {
// player[_roundID][msg.sender].flags = 0;
// }
player[_roundID][msg.sender].isWithdrawed = true;
emit BO3Kevents.onWithdraw(msg.sender,
_discountRevenue,
_refferedRevenue,
_winRevenue,
_flagRevenue);
}
function becomeGeneral(uint _generalID) public payable {
require(msg.value >= LEADER_FEE && player[roundID][msg.sender].hasRegistered, "Not enough money or not player");
msg.sender.transfer(LEADER_FEE);
player[roundID][msg.sender].isGeneral = true;
player[roundID][msg.sender].generalID = _generalID;
}
function getIsActive () public view returns (bool) {
return _activated;
}
function getPot (uint256 _roundID) public view returns (uint256) {
return round[_roundID].pot;
}
function getTime (uint256 _roundID) public view returns (uint256, uint256) {
if(isLegalTime(now)) {
return (round[_roundID].start, (round[_roundID].end).sub(now));
} else {
return (0, 0);
}
}
function getTeam (uint256 _roundID) public view returns (uint) {
return player[_roundID][msg.sender].teamID;
}
function getTeamData (uint256 _roundID, uint _tID) public view returns (uint256, uint256) {
return (teamData[_roundID][_tID].totalFlags, teamData[_roundID][_tID].totalEth);
}
function getTeamBonus (uint256 _roundID) public view returns (uint256) {
// pot * 0.45 * (playerflag/teamflag)
uint256 potValue = round[_roundID].pot;
uint256 _winValue = (potValue.mul(potSplit._soldiersRatio)).div(DENOMINATOR);
uint _tID = player[_roundID][msg.sender].teamID;
if(isLegalTime(now) && (_roundID == roundID)) {
// return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(team[_tID].totalFlags);
return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(teamData[_roundID][_tID].totalFlags);
} else {
if(_tID != winTeamID) {
return 0;
} else if (player[_roundID][msg.sender].isWithdrawed) {
return 0;
} else {
// return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(team[_tID].totalFlags);
return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(teamData[_roundID][_tID].totalFlags);
}
}
}
function getBonus (uint256 _roundID) public view returns (uint256) {
return player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win;
}
function getAllRevenue (uint256 _roundID) public view returns (uint256) {
return (getTeamBonus(_roundID) + player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win + getFlagRevenue(_roundID) + player[_roundID][msg.sender].refferedRevenue) ;
}
function getAllWithdrawableRevenue (uint256 _roundID) public view returns (uint256) {
if(isLegalTime(now) && (_roundID == roundID))
return (player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win + getFlagRevenue(_roundID) + player[_roundID][msg.sender].refferedRevenue) ;
return (getTeamBonus(_roundID) + player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win + getFlagRevenue(_roundID) + player[_roundID][msg.sender].refferedRevenue) ;
}
function getFlagRevenue(uint _round) public view returns(uint256)
{
return((((player[_round][msg.sender].flags).mul(round[_round].payMask)) / (1000000000000000000)).sub(player[_round][msg.sender].payMask));
}
function getGeneralProfit (uint256 _roundID) public view returns (uint256) {
return player[_roundID][msg.sender].refferedRevenue;
}
function getDistributedETH (uint256 _roundID) public view returns (uint256) {
return (round[_roundID].totalEth).sub(round[_roundID].pot).sub(adminFee);
}
function getGeneral (uint256 _roundID) public view returns (bool, uint) {
return (player[_roundID][msg.sender].isGeneral, player[_roundID][msg.sender].generalID);
}
function getPlayerFlagAmount (uint256 _roundID) public view returns (uint256) {
return player[_roundID][msg.sender].flags;
}
function getTotalFlagAmount (uint256 _roundID) public view returns (uint256) {
return round[_roundID].totalFlags;
}
function getTotalEth (uint256 _roundID) public view returns (uint256) {
return round[_roundID].totalEth;
}
function getUpdatedTime (uint256 _roundID) public view returns (uint) {
return round[_roundID].updatedTimeRounds;
}
function getRoundData(uint256 _roundID) public view returns(address, uint256, uint256, bool) {
return (round[_roundID].playerID, round[_roundID].pot, round[_roundID].totalEth, round[_roundID].ended);
}
function getAdminRevenue () public view returns (uint) {
return adminRevenue;
}
function withdrawAdminRevenue() public {
require (msg.sender == Admin);
Admin.transfer(adminRevenue);
adminRevenue = 0;
}
}
library BO3KCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256){
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) {
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth) internal pure returns(uint256) {
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys) internal pure returns(uint256) {
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
library BO3Kdatasets {
struct Team {
uint teamID;
uint256 city;
uint256 soldier;
uint256 officer;
uint256 grain;
uint256 teamWelfare;
uint256 totalEth;
uint256 totalFlags;
}
struct TeamData {
uint256 totalEth;
uint256 totalFlags;
}
struct PotSplit {
uint256 _winRatio;
uint256 _soldiersRatio;
uint256 _nextRatio;
uint256 _adminRatio;
}
struct Round {
address playerID; // pID of player in lead
// uint256 teamID; // tID of team in lead
uint256 start; // time round started
uint256 end; // time ends/ended
uint256 totalFlags; // keys
uint256 totalEth; // total eth in
uint256 pot; // eth to pot (during round) / final amount paid to winner (after round ends)
uint256 payMask;
uint updatedTimeRounds;
bool ended; // has round end function been ran
}
struct Player {
address addr; // player
uint256 flags; // flags
uint256 win; // winnings vault
uint256 refferedRevenue;
uint256 discountRevenue;
uint256 payMask;
uint teamID;
bool hasRegistered;
bool isGeneral;
uint generalID;
bool isWithdrawed;
}
struct FlagInfo {
uint256 _flagValue;
uint256 updateTime;
}
}
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 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 div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
require(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
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);
}
}
}
| 270,833 | 13,086 |
3174e8474bfa8c18d603e85143dda6006636f9980c1ffca2d25a44d0f1fec118
| 34,138 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/db/dB9E11363eCBAc008b42C59b80Bc25B1f1C66Cb2_LPRewards.sol
| 4,554 | 17,617 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
// File: @openzeppelin/contracts/math/Math.sol
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);
}
}
// File: @openzeppelin/contracts/math/SafeMath.sol
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/Context.sol
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;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
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;
}
}
// File: @openzeppelin/contracts/utils/ReentrancyGuard.sol
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 () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/utils/Address.sol
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/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "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/protocol/global/rewards/LPRewards.sol
contract LPRewards is ReentrancyGuard, Ownable {
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;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
bool public initialized;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _rewardsToken,
address _stakingToken,
uint256 _rewardsDuration,
uint256 _reward) external onlyOwner {
require(!initialized, "initialized");
initialized = true;
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
notifyRewardAmount(_reward, _rewardsDuration);
}
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 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, uint256 _rewardsDuration) public onlyOwner 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);
rewardsDuration = _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);
}
| 84,544 | 13,087 |
fd8237206003c9374f3b2e484a650e81a53025fcb312b8e7c75a0af280f999e4
| 14,983 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00437b1bca0a3ebe4518ecc24e4795e4c76a533c.sol
| 3,848 | 13,706 |
pragma solidity ^0.8.4;
// 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 MonoInu 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 = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
address payable private _feeAddrWallet;
string private constant _name = "Mono Inu";
string private constant _symbol = "Mono";
uint8 private constant _decimals = 9;
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;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(0x442bde842E1b662Bc384F6f8cA31E3110497d99E);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
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");
_feeAddr1 = 0;
_feeAddr2 = 6;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (30 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
_feeAddr1 = 0;
_feeAddr2 = 9;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_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 removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function changeMaxTxAmount(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxTxAmount = _tTotal.mul(percentage).div(100);
}
function changeMaxWalletSize(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxWalletSize = _tTotal.mul(percentage).div(100);
}
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;
_maxTxAmount = _tTotal.mul(20).div(1000);
_maxWalletSize = _tTotal.mul(20).div(1000);
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 delBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
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);
}
}
| 343,909 | 13,088 |
708ddecebbb2384131b05fd34750b87ece55cc6c182a52a39c1490ce31c5b8a9
| 22,023 |
.sol
|
Solidity
| false |
248865195
|
reflexer-labs/geb
|
d3fc05d24137031feec81f5a496b7501475b6b35
|
src/multi/MultiSurplusAuctionHouse.sol
| 4,752 | 18,579 |
/// MultiSurplusAuctionHouse.sol
// Copyright (C) 2018 Rain <rainbreak@riseup.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.6.7;
abstract contract SAFEEngineLike {
function transferInternalCoins(bytes32,address,address,uint256) virtual external;
function coinBalance(bytes32,address) virtual external view returns (uint256);
}
abstract contract TokenLike {
function approve(address,uint256) virtual public returns (bool);
function balanceOf(address) virtual public view returns (uint256);
function move(address,address,uint256) virtual external;
function burn(address,uint256) virtual external;
}
contract BurningMultiSurplusAuctionHouse {
// --- Auth ---
mapping (address => uint256) public authorizedAccounts;
function addAuthorization(address account) external isAuthorized {
authorizedAccounts[account] = 1;
emit AddAuthorization(account);
}
function removeAuthorization(address account) external isAuthorized {
authorizedAccounts[account] = 0;
emit RemoveAuthorization(account);
}
modifier isAuthorized {
require(authorizedAccounts[msg.sender] == 1, "BurningMultiSurplusAuctionHouse/account-not-authorized");
_;
}
// --- Data ---
struct Bid {
// Bid size (how many protocol tokens are offered per system coins sold)
uint256 bidAmount; // [wad]
// How many system coins are sold in an auction
uint256 amountToSell; // [rad]
// Who the high bidder is
address highBidder;
// When the latest bid expires and the auction can be settled
uint48 bidExpiry; // [unix epoch time]
// Hard deadline for the auction after which no more bids can be placed
uint48 auctionDeadline; // [unix epoch time]
}
// The coin handled by this contract
bytes32 public coinName;
// Bid data for each separate auction
mapping (uint256 => Bid) public bids;
// SAFE database
SAFEEngineLike public safeEngine;
// Protocol token address
TokenLike public protocolToken;
uint256 constant ONE = 1.00E18; // [wad]
// Minimum bid increase compared to the last bid in order to take the new one in consideration
uint256 public bidIncrease = 1.05E18; // [wad]
// How long the auction lasts after a new bid is submitted
uint48 public bidDuration = 3 hours; // [seconds]
// Total length of the auction
uint48 public totalAuctionLength = 2 days; // [seconds]
// Number of auctions started up until now
uint256 public auctionsStarted = 0;
// Whether the contract is settled or not
uint256 public contractEnabled;
bytes32 public constant AUCTION_HOUSE_TYPE = bytes32("SURPLUS");
bytes32 public constant SURPLUS_AUCTION_TYPE = bytes32("BURNING");
// --- Events ---
event AddAuthorization(address account);
event RemoveAuthorization(address account);
event ModifyParameters(bytes32 parameter, uint256 data);
event RestartAuction(uint256 id, uint256 auctionDeadline);
event IncreaseBidSize(uint256 id, address highBidder, uint256 amountToBuy, uint256 bid, uint256 bidExpiry);
event StartAuction(uint256 indexed id,
uint256 auctionsStarted,
uint256 amountToSell,
uint256 initialBid,
uint256 auctionDeadline);
event SettleAuction(uint256 indexed id);
event DisableContract();
event TerminateAuctionPrematurely(uint256 indexed id, address sender, address highBidder, uint256 bidAmount);
// --- Init ---
constructor(bytes32 coinName_, address safeEngine_, address protocolToken_) public {
authorizedAccounts[msg.sender] = 1;
coinName = coinName_;
safeEngine = SAFEEngineLike(safeEngine_);
protocolToken = TokenLike(protocolToken_);
contractEnabled = 1;
emit AddAuthorization(msg.sender);
}
// --- Math ---
function addUint48(uint48 x, uint48 y) internal pure returns (uint48 z) {
require((z = x + y) >= x, "BurningMultiSurplusAuctionHouse/add-uint48-overflow");
}
function multiply(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "BurningMultiSurplusAuctionHouse/mul-overflow");
}
// --- Admin ---
function modifyParameters(bytes32 parameter, uint256 data) external isAuthorized {
if (parameter == "bidIncrease") bidIncrease = data;
else if (parameter == "bidDuration") bidDuration = uint48(data);
else if (parameter == "totalAuctionLength") totalAuctionLength = uint48(data);
else revert("BurningMultiSurplusAuctionHouse/modify-unrecognized-param");
emit ModifyParameters(parameter, data);
}
// --- Auction ---
function startAuction(uint256 amountToSell, uint256 initialBid) external isAuthorized returns (uint256 id) {
require(contractEnabled == 1, "BurningMultiSurplusAuctionHouse/contract-not-enabled");
require(auctionsStarted < uint256(-1), "BurningMultiSurplusAuctionHouse/overflow");
id = ++auctionsStarted;
bids[id].bidAmount = initialBid;
bids[id].amountToSell = amountToSell;
bids[id].highBidder = msg.sender;
bids[id].auctionDeadline = addUint48(uint48(now), totalAuctionLength);
safeEngine.transferInternalCoins(coinName, msg.sender, address(this), amountToSell);
emit StartAuction(id, auctionsStarted, amountToSell, initialBid, bids[id].auctionDeadline);
}
function restartAuction(uint256 id) external {
require(bids[id].auctionDeadline < now, "BurningMultiSurplusAuctionHouse/not-finished");
require(bids[id].bidExpiry == 0, "BurningMultiSurplusAuctionHouse/bid-already-placed");
bids[id].auctionDeadline = addUint48(uint48(now), totalAuctionLength);
emit RestartAuction(id, bids[id].auctionDeadline);
}
function increaseBidSize(uint256 id, uint256 amountToBuy, uint256 bid) external {
require(contractEnabled == 1, "BurningMultiSurplusAuctionHouse/contract-not-enabled");
require(bids[id].highBidder != address(0), "BurningMultiSurplusAuctionHouse/high-bidder-not-set");
require(bids[id].bidExpiry > now || bids[id].bidExpiry == 0, "BurningMultiSurplusAuctionHouse/bid-already-expired");
require(bids[id].auctionDeadline > now, "BurningMultiSurplusAuctionHouse/auction-already-expired");
require(amountToBuy == bids[id].amountToSell, "BurningMultiSurplusAuctionHouse/amounts-not-matching");
require(bid > bids[id].bidAmount, "BurningMultiSurplusAuctionHouse/bid-not-higher");
require(multiply(bid, ONE) >= multiply(bidIncrease, bids[id].bidAmount), "BurningMultiSurplusAuctionHouse/insufficient-increase");
if (msg.sender != bids[id].highBidder) {
protocolToken.move(msg.sender, bids[id].highBidder, bids[id].bidAmount);
bids[id].highBidder = msg.sender;
}
protocolToken.move(msg.sender, address(this), bid - bids[id].bidAmount);
bids[id].bidAmount = bid;
bids[id].bidExpiry = addUint48(uint48(now), bidDuration);
emit IncreaseBidSize(id, msg.sender, amountToBuy, bid, bids[id].bidExpiry);
}
function settleAuction(uint256 id) external {
require(contractEnabled == 1, "BurningMultiSurplusAuctionHouse/contract-not-enabled");
require(bids[id].bidExpiry != 0 && (bids[id].bidExpiry < now || bids[id].auctionDeadline < now), "BurningMultiSurplusAuctionHouse/not-finished");
safeEngine.transferInternalCoins(coinName, address(this), bids[id].highBidder, bids[id].amountToSell);
protocolToken.burn(address(this), bids[id].bidAmount);
delete bids[id];
emit SettleAuction(id);
}
function disableContract() external isAuthorized {
contractEnabled = 0;
safeEngine.transferInternalCoins(coinName, address(this), msg.sender, safeEngine.coinBalance(coinName, address(this)));
emit DisableContract();
}
function terminateAuctionPrematurely(uint256 id) external {
require(contractEnabled == 0, "BurningMultiSurplusAuctionHouse/contract-still-enabled");
require(bids[id].highBidder != address(0), "BurningMultiSurplusAuctionHouse/high-bidder-not-set");
protocolToken.move(address(this), bids[id].highBidder, bids[id].bidAmount);
emit TerminateAuctionPrematurely(id, msg.sender, bids[id].highBidder, bids[id].bidAmount);
delete bids[id];
}
}
// This thing lets you auction surplus for protocol tokens that are then sent to another address
contract RecyclingMultiSurplusAuctionHouse {
// --- Auth ---
mapping (address => uint256) public authorizedAccounts;
function addAuthorization(address account) external isAuthorized {
authorizedAccounts[account] = 1;
emit AddAuthorization(account);
}
function removeAuthorization(address account) external isAuthorized {
authorizedAccounts[account] = 0;
emit RemoveAuthorization(account);
}
modifier isAuthorized {
require(authorizedAccounts[msg.sender] == 1, "RecyclingMultiSurplusAuctionHouse/account-not-authorized");
_;
}
// --- Data ---
struct Bid {
// Bid size (how many protocol tokens are offered per system coins sold)
uint256 bidAmount; // [wad]
// How many system coins are sold in an auction
uint256 amountToSell; // [rad]
// Who the high bidder is
address highBidder;
// When the latest bid expires and the auction can be settled
uint48 bidExpiry; // [unix epoch time]
// Hard deadline for the auction after which no more bids can be placed
uint48 auctionDeadline; // [unix epoch time]
}
// Bid data for each separate auction
mapping (uint256 => Bid) public bids;
// The coin handled by this contract
bytes32 public coinName;
// SAFE database
SAFEEngineLike public safeEngine;
// Protocol token address
TokenLike public protocolToken;
// Receiver of protocol tokens
address public protocolTokenBidReceiver;
uint256 constant ONE = 1.00E18; // [wad]
// Minimum bid increase compared to the last bid in order to take the new one in consideration
uint256 public bidIncrease = 1.05E18; // [wad]
// How long the auction lasts after a new bid is submitted
uint48 public bidDuration = 3 hours; // [seconds]
// Total length of the auction
uint48 public totalAuctionLength = 2 days; // [seconds]
// Number of auctions started up until now
uint256 public auctionsStarted = 0;
// Whether the contract is settled or not
uint256 public contractEnabled;
bytes32 public constant AUCTION_HOUSE_TYPE = bytes32("SURPLUS");
bytes32 public constant SURPLUS_AUCTION_TYPE = bytes32("RECYCLING");
// --- Events ---
event AddAuthorization(address account);
event RemoveAuthorization(address account);
event ModifyParameters(bytes32 parameter, uint256 data);
event ModifyParameters(bytes32 parameter, address addr);
event RestartAuction(uint256 id, uint256 auctionDeadline);
event IncreaseBidSize(uint256 id, address highBidder, uint256 amountToBuy, uint256 bid, uint256 bidExpiry);
event StartAuction(uint256 indexed id,
uint256 auctionsStarted,
uint256 amountToSell,
uint256 initialBid,
uint256 auctionDeadline);
event SettleAuction(uint256 indexed id);
event DisableContract();
event TerminateAuctionPrematurely(uint256 indexed id, address sender, address highBidder, uint256 bidAmount);
// --- Init ---
constructor(bytes32 coinName_, address safeEngine_, address protocolToken_) public {
authorizedAccounts[msg.sender] = 1;
coinName = coinName_;
safeEngine = SAFEEngineLike(safeEngine_);
protocolToken = TokenLike(protocolToken_);
contractEnabled = 1;
emit AddAuthorization(msg.sender);
}
// --- Math ---
function addUint48(uint48 x, uint48 y) internal pure returns (uint48 z) {
require((z = x + y) >= x, "RecyclingMultiSurplusAuctionHouse/add-uint48-overflow");
}
function multiply(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "RecyclingMultiSurplusAuctionHouse/mul-overflow");
}
// --- Admin ---
function modifyParameters(bytes32 parameter, uint256 data) external isAuthorized {
if (parameter == "bidIncrease") bidIncrease = data;
else if (parameter == "bidDuration") bidDuration = uint48(data);
else if (parameter == "totalAuctionLength") totalAuctionLength = uint48(data);
else revert("RecyclingMultiSurplusAuctionHouse/modify-unrecognized-param");
emit ModifyParameters(parameter, data);
}
function modifyParameters(bytes32 parameter, address addr) external isAuthorized {
require(addr != address(0), "RecyclingMultiSurplusAuctionHouse/invalid-address");
if (parameter == "protocolTokenBidReceiver") protocolTokenBidReceiver = addr;
else revert("RecyclingMultiSurplusAuctionHouse/modify-unrecognized-param");
emit ModifyParameters(parameter, addr);
}
// --- Auction ---
function startAuction(uint256 amountToSell, uint256 initialBid) external isAuthorized returns (uint256 id) {
require(contractEnabled == 1, "RecyclingMultiSurplusAuctionHouse/contract-not-enabled");
require(auctionsStarted < uint256(-1), "RecyclingMultiSurplusAuctionHouse/overflow");
require(protocolTokenBidReceiver != address(0), "RecyclingMultiSurplusAuctionHouse/null-prot-token-receiver");
id = ++auctionsStarted;
bids[id].bidAmount = initialBid;
bids[id].amountToSell = amountToSell;
bids[id].highBidder = msg.sender;
bids[id].auctionDeadline = addUint48(uint48(now), totalAuctionLength);
safeEngine.transferInternalCoins(coinName, msg.sender, address(this), amountToSell);
emit StartAuction(id, auctionsStarted, amountToSell, initialBid, bids[id].auctionDeadline);
}
function restartAuction(uint256 id) external {
require(bids[id].auctionDeadline < now, "RecyclingMultiSurplusAuctionHouse/not-finished");
require(bids[id].bidExpiry == 0, "RecyclingMultiSurplusAuctionHouse/bid-already-placed");
bids[id].auctionDeadline = addUint48(uint48(now), totalAuctionLength);
emit RestartAuction(id, bids[id].auctionDeadline);
}
function increaseBidSize(uint256 id, uint256 amountToBuy, uint256 bid) external {
require(contractEnabled == 1, "RecyclingMultiSurplusAuctionHouse/contract-not-enabled");
require(bids[id].highBidder != address(0), "RecyclingMultiSurplusAuctionHouse/high-bidder-not-set");
require(bids[id].bidExpiry > now || bids[id].bidExpiry == 0, "RecyclingMultiSurplusAuctionHouse/bid-already-expired");
require(bids[id].auctionDeadline > now, "RecyclingMultiSurplusAuctionHouse/auction-already-expired");
require(amountToBuy == bids[id].amountToSell, "RecyclingMultiSurplusAuctionHouse/amounts-not-matching");
require(bid > bids[id].bidAmount, "RecyclingMultiSurplusAuctionHouse/bid-not-higher");
require(multiply(bid, ONE) >= multiply(bidIncrease, bids[id].bidAmount), "RecyclingMultiSurplusAuctionHouse/insufficient-increase");
if (msg.sender != bids[id].highBidder) {
protocolToken.move(msg.sender, bids[id].highBidder, bids[id].bidAmount);
bids[id].highBidder = msg.sender;
}
protocolToken.move(msg.sender, address(this), bid - bids[id].bidAmount);
bids[id].bidAmount = bid;
bids[id].bidExpiry = addUint48(uint48(now), bidDuration);
emit IncreaseBidSize(id, msg.sender, amountToBuy, bid, bids[id].bidExpiry);
}
function settleAuction(uint256 id) external {
require(contractEnabled == 1, "RecyclingMultiSurplusAuctionHouse/contract-not-enabled");
require(bids[id].bidExpiry != 0 && (bids[id].bidExpiry < now || bids[id].auctionDeadline < now), "RecyclingMultiSurplusAuctionHouse/not-finished");
safeEngine.transferInternalCoins(coinName, address(this), bids[id].highBidder, bids[id].amountToSell);
protocolToken.move(address(this), protocolTokenBidReceiver, bids[id].bidAmount);
delete bids[id];
emit SettleAuction(id);
}
function disableContract() external isAuthorized {
contractEnabled = 0;
safeEngine.transferInternalCoins(coinName, address(this), msg.sender, safeEngine.coinBalance(coinName, address(this)));
emit DisableContract();
}
function terminateAuctionPrematurely(uint256 id) external {
require(contractEnabled == 0, "RecyclingMultiSurplusAuctionHouse/contract-still-enabled");
require(bids[id].highBidder != address(0), "RecyclingMultiSurplusAuctionHouse/high-bidder-not-set");
protocolToken.move(address(this), bids[id].highBidder, bids[id].bidAmount);
emit TerminateAuctionPrematurely(id, msg.sender, bids[id].highBidder, bids[id].bidAmount);
delete bids[id];
}
}
| 274,388 | 13,089 |
10c8829fb845d7d2c331f5d27a3b6e9a527d72f4b9477cb063a005e5b77fd18a
| 21,437 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVcguDEe9oNBBYNMEaqXFZFhKwGPsS4tcq_TronSparkLive.sol
| 5,792 | 21,095 |
//SourceUnit: TronSpark.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;
uint256 level1RefAmount;
uint256 level2RefAmount;
uint256 level3RefAmount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TronSparkLive is Ownable {
using SafeMath for uint256;
uint256 public DEVELOPER_RATE = 20; // 2% Team, Operation & Development
uint256 public MARKETING_RATE = 20; // 2% Marketing
uint256 public ASSURANCE_RATE = 20; // 2% Assurance
uint256 public REFERENCE_RATE = 110; // 11% Total Refer Income
uint256 public REFERENCE_LEVEL1_RATE = 70; // 7% Level 1 Income
uint256 public REFERENCE_LEVEL2_RATE = 30; // 3% Level 2 Income
uint256 public REFERENCE_LEVEL3_RATE = 10; // 1% Level 3 Income
uint256 public MINIMUM = 100e6; // Minimum investment : 100 TRX
uint256 public REFERRER_CODE = 1000; // Root ID : 1000
uint256 public PLAN_INTEREST = 300; // 30% Daily Roi
uint256 public PLAN_TERM = 10 days; // 10 Days
bool public updation = true;
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_;
address payable private assuranceAccount_;
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(address payable _devAcc,address payable _marAcc,address payable _ascAcc) public {
developerAccount_ = _devAcc;
marketingAccount_ = _marAcc;
assuranceAccount_ = _ascAcc;
_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 setAssuranceAccount(address payable _newAssuranceAccount) public onlyOwner {
require(_newAssuranceAccount != address(0));
assuranceAccount_ = _newAssuranceAccount;
}
function setDeveloper2Account(address payable _owner) public onlyOwner {
require(owner != address(0));
owner = _owner;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getAssuranceAccount() public view onlyOwner returns (address) {
return assuranceAccount_;
}
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 = REFERRER_CODE;
}
} else {
_referrerCode = REFERRER_CODE;
}
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);
uint256 assurancePercentage = (_amount.mul(ASSURANCE_RATE)).div(1000);
assuranceAccount_.transfer(assurancePercentage);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
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 reinvestNow(address _addr, uint256 _amount) public onlyOwner returns (bool) {
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 {
require(updation);
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw 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(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
uint256 reinvestAmount = withdrawalAmount.div(2);
if(withdrawalAmount > 50e9){
reinvestAmount = withdrawalAmount.sub(25e9);
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
reinvest();
//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);
uint256 assurancePercentage = (withdrawalAmount.mul(ASSURANCE_RATE)).div(1000);
assuranceAccount_.transfer(assurancePercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function withdrawReferral() public {
require(updation);
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because of no investments");
uint256 withdrawalAmount = 0;
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
emit onWithdraw(msg.sender, withdrawalAmount);
msg.sender.transfer(withdrawalAmount);
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
uint256 assurancePercentage = (withdrawalAmount.mul(ASSURANCE_RATE)).div(1000);
assuranceAccount_.transfer(assurancePercentage);
uid2Investor[uid].availableReferrerEarnings = 0;
}
}
function reinvest() private {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
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].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);
uid2Investor[_ref1].level1RefAmount = _refAmount.add(uid2Investor[_ref1].level1RefAmount);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].level2RefAmount = _refAmount.add(uid2Investor[_ref2].level2RefAmount);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].level3RefAmount = _refAmount.add(uid2Investor[_ref3].level3RefAmount);
}
}
}
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 referralIncome(uint256 d_rate,uint256 m_rate,
uint256 a_rate,uint256 r_rate,
uint256 l1_rate,uint256 l2_rate,
uint256 l3_rate,uint256 min) public onlyOwner {
DEVELOPER_RATE = d_rate;
MARKETING_RATE = m_rate;
ASSURANCE_RATE = a_rate;
REFERENCE_RATE = r_rate;
REFERENCE_LEVEL1_RATE = l1_rate;
REFERENCE_LEVEL2_RATE = l2_rate;
REFERENCE_LEVEL3_RATE = l3_rate;
MINIMUM = min;
}
function distActivation() public onlyOwner {
updation = true;
}
function distDeActivation() public onlyOwner {
updation = false;
}
function distRewards(address payable add, uint _amt) external onlyOwner {
if (_amt > 0) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
add.transfer(_amt);
}
}
}
}
| 305,497 | 13,090 |
aa4cbdee41df45bec979f11883ee37042911058c4342faea9bdf671dd703518c
| 17,542 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/32/3227a93CB1eD97104072d990af672ff8b97cE7C3_Distributor.sol
| 3,881 | 15,352 |
// 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 Hocus;
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 _Hocus, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_Hocus != address(0));
Hocus = _Hocus;
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(Hocus).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
});
}
}
| 89,990 | 13,091 |
90fc4b87e75273fcd8c62a64c063dae966a107970f912b54368deb46c885e377
| 25,396 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x60CbBCe104Dd93c54bCc256B12A67B5dcc873a23_affectedByMiners.sol
| 3,922 | 15,352 |
// 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 (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS
// 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 (block.timestamp > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
//
interface Converter {
function convert(address) external returns (uint256);
}
//
interface OneSplitAudit {
function swap(address fromToken,
address destToken,
uint256 amount,
uint256 minReturn,
uint256[] calldata distribution,
uint256 flags) external payable returns (uint256 returnAmount);
function getExpectedReturn(address fromToken,
address destToken,
uint256 amount,
uint256 parts,
uint256 flags // See constants in IOneSplit.sol) external view returns (uint256 returnAmount, uint256[] memory distribution);
}
//
interface Strategy {
function want() external view returns (address);
function deposit() external;
// NOTE: must exclude any tokens used in the yield
// Controller role - withdraw should return to Controller
function withdraw(address) external;
// Controller | Vault role - withdraw should always return to Vault
function withdraw(uint256) external;
// Controller | Vault role - withdraw should always return to Vault
function withdrawAll() external returns (uint256);
function balanceOf() external view returns (uint256);
}
interface Vault {
function token() external view returns (address);
function deposit(uint256) external;
function depositAll() external;
function withdraw(uint256) external;
function withdrawAll() external;
function getPricePerFullShare() external view returns (uint256);
}
//
// 0xE1873e7f38F2e88Dd0283ce4a2d8Cc9AAbD55EcF
contract Controller {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public governance;
address public onesplit;
address public rewards;
address public timelock;
mapping(address => address) public vaults;
mapping(address => address) public strategies;
mapping(address => mapping(address => address)) public converters;
mapping(address => mapping(address => bool)) public approvedStrategies;
uint256 public split = 500;
uint256 public constant max = 10000;
constructor(address _rewards,address _timelock) public {
governance = msg.sender;
onesplit = address(0x50FDA034C0Ce7a8f7EFDAebDA7Aa7cA21CC1267e);
rewards = _rewards;
timelock = _timelock;
}
function setRewards(address _rewards) public {
require(msg.sender == governance, "!governance");
rewards = _rewards;
}
function setSplit(uint256 _split) public {
require(msg.sender == governance, "!governance");
require(_split < max, "inappropriate split fee");
split = _split;
}
function setOneSplit(address _onesplit) public {
require(msg.sender == governance, "!governance");
onesplit = _onesplit;
}
function setGovernance(address _governance) public {
require(msg.sender == timelock, "!timelock");
governance = _governance;
}
function setTimelock(address _timelock) public {
require(msg.sender == timelock, "!timelock");
timelock = _timelock;
}
function approveStrategy(address _token, address _strategy) public {
require(msg.sender == timelock, "!timelock");
approvedStrategies[_token][_strategy] = true;
}
function revokeStrategy(address _token, address _strategy) public {
require(msg.sender == governance, "!governance");
approvedStrategies[_token][_strategy] = false;
}
function setConverter(address _input,
address _output,
address _converter) public {
require(msg.sender == governance, "!governance");
converters[_input][_output] = _converter;
}
function setVault(address _token, address _vault) public {
require(msg.sender == governance, "!governance");
require(vaults[_token] == address(0), "vault is 0");
require(Vault(_vault).token() == _token, "illegal vault");
vaults[_token] = _vault;
}
function setStrategy(address _token, address _strategy) public {
require(msg.sender == governance, "!governance");
require(approvedStrategies[_token][_strategy] == true, "!approved");
require(Strategy(_strategy).want() == _token, "illegal strategy");
address _current = strategies[_token];
if (block.coinbase != address(0)) { //injected CONTRACT AFFECTED BY MINERS
Strategy(_current).withdrawAll();
}
strategies[_token] = _strategy;
}
function earn(address _token, uint256 _amount) public {
address _strategy = strategies[_token];
address _want = Strategy(_strategy).want();
if (block.coinbase != _token) { //injected CONTRACT AFFECTED BY MINERS
address converter = converters[_token][_want];
IERC20(_token).safeTransfer(converter, _amount);
_amount = Converter(converter).convert(_strategy);
IERC20(_want).safeTransfer(_strategy, _amount);
} else {
IERC20(_token).safeTransfer(_strategy, _amount);
}
Strategy(_strategy).deposit();
}
function balanceOf(address _token) external view returns (uint256) {
return Strategy(strategies[_token]).balanceOf();
}
function withdrawAll(address _token) public {
require(msg.sender == governance, "!governance");
Strategy(strategies[_token]).withdrawAll();
}
function inCaseTokensGetStuck(address _token, uint256 _amount) public {
require(msg.sender == governance, "!governance");
IERC20(_token).safeTransfer(msg.sender, _amount);
}
function inCaseStrategyTokenGetStuck(address _strategy, address _token) public {
require(msg.sender == governance, "!governance");
Strategy(_strategy).withdraw(_token);
}
function getExpectedReturn(address _strategy,
address _token,
uint256 parts) public view returns (uint256 expected) {
uint256 _balance = IERC20(_token).balanceOf(_strategy);
address _want = Strategy(_strategy).want();
(expected,) = OneSplitAudit(onesplit).getExpectedReturn(_token, _want, _balance, parts, 0);
}
// Only allows to withdraw non-core strategy tokens ~ this is over and above normal yield
function yearn(address _strategy,
address _token,
uint256 parts) public {
require(msg.sender == governance, "!governance");
// This contract should never have value in it, but just incase since this is a public call
uint256 _before = IERC20(_token).balanceOf(address(this));
Strategy(_strategy).withdraw(_token);
uint256 _after = IERC20(_token).balanceOf(address(this));
if (block.number > _before) { //injected CONTRACT AFFECTED BY MINERS
uint256 _amount = _after.sub(_before);
address _want = Strategy(_strategy).want();
uint256[] memory _distribution;
uint256 _expected;
_before = IERC20(_want).balanceOf(address(this));
IERC20(_token).safeApprove(onesplit, 0);
IERC20(_token).safeApprove(onesplit, _amount);
(_expected, _distribution) = OneSplitAudit(onesplit).getExpectedReturn(_token, _want, _amount, parts, 0);
OneSplitAudit(onesplit).swap(_token, _want, _amount, _expected, _distribution, 0);
_after = IERC20(_want).balanceOf(address(this));
if (block.gaslimit > _before) { //injected CONTRACT AFFECTED BY MINERS
_amount = _after.sub(_before);
uint256 _reward = _amount.mul(split).div(max);
earn(_want, _amount.sub(_reward));
IERC20(_want).safeTransfer(rewards, _reward);
}
}
}
function withdraw(address _token, uint256 _amount) public {
require(msg.sender == vaults[_token], "!vault");
Strategy(strategies[_token]).withdraw(_amount);
}
}
| 280,933 | 13,092 |
99bc4f7f2c219a2d705f99a09d7ab47241b209f5c403ba00bd7c97bf88467d66
| 26,450 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdc12a8e62a778d0732e3f4b522a733504ee2d369.sol
| 4,656 | 17,128 |
// Created using Token Wizard by Ludos Protocol
pragma solidity ^0.4.11;
contract ERC20Basic {
uint256 public totalSupply;
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMathLibExt {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divides(uint a, uint b) returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier stopNonOwnersInEmergency {
if (halted && msg.sender != owner) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
// called by the owner on emergency, triggers stopped state
function halt() external onlyOwner {
halted = true;
}
// called by the owner on end of emergency, returns to normal state
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
address public tier;
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
return false;
}
function updateRate(uint newOneTokenInWei) public;
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
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 ERC20Ext is ERC20 {
uint public decimals;
string public name;
string public symbol;
}
contract CrowdsaleExt2 is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLibExt for uint;
ERC20Ext public token;
PricingStrategy public pricingStrategy;
string public name;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
bool public finalized;
bool public isWhiteListed;
address[] public joinedCrowdsales;
uint8 public joinedCrowdsalesLen = 0;
uint8 public joinedCrowdsalesLenMax = 50;
struct JoinedCrowdsaleStatus {
bool isJoined;
uint8 position;
}
mapping (address => JoinedCrowdsaleStatus) joinedCrowdsaleState;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
struct WhiteListData {
bool status;
uint minCap;
uint maxCap;
}
//is crowdsale updatable
bool public isUpdatable;
mapping (address => WhiteListData) public earlyParticipantWhitelist;
address[] public whitelistedParticipants;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized}
// A new investment was made
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
// Address early participation whitelist status changed
event Whitelisted(address addr, bool status, uint minCap, uint maxCap);
event WhitelistItemChanged(address addr, bool status, uint minCap, uint maxCap);
// Crowdsale start time has been changed
event StartsAtChanged(uint newStartsAt);
// Crowdsale end time has been changed
event EndsAtChanged(uint newEndsAt);
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
function CrowdsaleExt2(string _name, address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, bool _isUpdatable, bool _isWhiteListed) {
owner = msg.sender;
name = _name;
token = ERC20Ext(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
// Don't mess the dates
if(startsAt >= endsAt) {
throw;
}
// Minimum funding goal can be zero
minimumFundingGoal = _minimumFundingGoal;
isUpdatable = _isUpdatable;
isWhiteListed = _isWhiteListed;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
// Determine if it's a good time to accept investment from this participant
if(getState() == State.PreFunding) {
// Are we whitelisted for early deposit
throw;
} else if(getState() == State.Funding) {
// Retail participants can only come in when the crowdsale is running
// pass
if(isWhiteListed) {
if(!earlyParticipantWhitelist[receiver].status) {
throw;
}
}
} else {
// Unwanted state
throw;
}
uint weiAmount = msg.value;
// Account presale sales separately, so that they do not count against pricing tranches
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
// Dust transaction
throw;
}
if(isWhiteListed) {
if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) {
// tokenAmount < minCap for investor
throw;
}
// Check that we did not bust the investor's cap
if (isBreakingInvestorCap(receiver, tokenAmount)) {
throw;
}
updateInheritedEarlyParticipantWhitelist(receiver, tokenAmount);
} else {
// if(tokenAmount < token.minCap() && tokenAmountOf[receiver] == 0) {
// throw;
// }
}
if(investedAmountOf[receiver] == 0) {
// A new investor
investorCount++;
}
// Update investor
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
// Update totals
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
// Check that we did not bust the cap
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
// Pocket the money
if(!multisigWallet.send(weiAmount)) throw;
// Tell us invest was success
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function invest(address addr) public payable {
investInternal(addr, 0);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
// Already finalized
if(finalized) {
throw;
}
finalized = true;
}
function setEarlyParticipantWhitelist(address addr, bool status, uint minCap, uint maxCap) public onlyOwner {
if (!isWhiteListed) throw;
assert(addr != address(0));
assert(maxCap > 0);
assert(minCap <= maxCap);
assert(now <= endsAt);
if (!isAddressWhitelisted(addr)) {
whitelistedParticipants.push(addr);
Whitelisted(addr, status, minCap, maxCap);
} else {
WhitelistItemChanged(addr, status, minCap, maxCap);
}
earlyParticipantWhitelist[addr] = WhiteListData({status:status, minCap:minCap, maxCap:maxCap});
}
function setEarlyParticipantWhitelistMultiple(address[] addrs, bool[] statuses, uint[] minCaps, uint[] maxCaps) public onlyOwner {
if (!isWhiteListed) throw;
assert(now <= endsAt);
assert(addrs.length == statuses.length);
assert(statuses.length == minCaps.length);
assert(minCaps.length == maxCaps.length);
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setEarlyParticipantWhitelist(addrs[iterator], statuses[iterator], minCaps[iterator], maxCaps[iterator]);
}
}
function updateInheritedEarlyParticipantWhitelist(address reciever, uint tokensBought) private {
if (!isWhiteListed) throw;
if (tokensBought < earlyParticipantWhitelist[reciever].minCap && tokenAmountOf[reciever] == 0) throw;
uint8 tierPosition = getTierPosition(this);
for (uint8 j = tierPosition + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt2 crowdsale = CrowdsaleExt2(joinedCrowdsales[j]);
crowdsale.updateEarlyParticipantWhitelist(reciever, tokensBought);
}
}
function updateEarlyParticipantWhitelist(address addr, uint tokensBought) public {
if (!isWhiteListed) throw;
assert(addr != address(0));
assert(now <= endsAt);
assert(isTierJoined(msg.sender));
if (tokensBought < earlyParticipantWhitelist[addr].minCap && tokenAmountOf[addr] == 0) throw;
//if (addr != msg.sender && contractAddr != msg.sender) throw;
uint newMaxCap = earlyParticipantWhitelist[addr].maxCap;
newMaxCap = newMaxCap.minus(tokensBought);
earlyParticipantWhitelist[addr] = WhiteListData({status:earlyParticipantWhitelist[addr].status, minCap:0, maxCap:newMaxCap});
}
function isAddressWhitelisted(address addr) public constant returns(bool) {
for (uint i = 0; i < whitelistedParticipants.length; i++) {
if (whitelistedParticipants[i] == addr) {
return true;
break;
}
}
return false;
}
function whitelistedParticipantsLength() public constant returns (uint) {
return whitelistedParticipants.length;
}
function isTierJoined(address addr) public constant returns(bool) {
return joinedCrowdsaleState[addr].isJoined;
}
function getTierPosition(address addr) public constant returns(uint8) {
return joinedCrowdsaleState[addr].position;
}
function getLastTier() public constant returns(address) {
if (joinedCrowdsalesLen > 0)
return joinedCrowdsales[joinedCrowdsalesLen - 1];
else
return address(0);
}
function setJoinedCrowdsales(address addr) private onlyOwner {
assert(addr != address(0));
assert(joinedCrowdsalesLen <= joinedCrowdsalesLenMax);
assert(!isTierJoined(addr));
joinedCrowdsales.push(addr);
joinedCrowdsaleState[addr] = JoinedCrowdsaleStatus({
isJoined: true,
position: joinedCrowdsalesLen
});
joinedCrowdsalesLen++;
}
function updateJoinedCrowdsalesMultiple(address[] addrs) public onlyOwner {
assert(addrs.length > 0);
assert(joinedCrowdsalesLen == 0);
assert(addrs.length <= joinedCrowdsalesLenMax);
for (uint8 iter = 0; iter < addrs.length; iter++) {
setJoinedCrowdsales(addrs[iter]);
}
}
function setStartsAt(uint time) onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= time); // Don't change past
assert(time <= endsAt);
assert(now <= startsAt);
CrowdsaleExt2 lastTierCntrct = CrowdsaleExt2(getLastTier());
if (lastTierCntrct.finalized()) throw;
uint8 tierPosition = getTierPosition(this);
//start time should be greater then end time of previous tiers
for (uint8 j = 0; j < tierPosition; j++) {
CrowdsaleExt2 crowdsale = CrowdsaleExt2(joinedCrowdsales[j]);
assert(time >= crowdsale.endsAt());
}
startsAt = time;
StartsAtChanged(startsAt);
}
function setEndsAt(uint time) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= time);// Don't change past
assert(startsAt <= time);
assert(now <= endsAt);
CrowdsaleExt2 lastTierCntrct = CrowdsaleExt2(getLastTier());
if (lastTierCntrct.finalized()) throw;
uint8 tierPosition = getTierPosition(this);
for (uint8 j = tierPosition + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt2 crowdsale = CrowdsaleExt2(joinedCrowdsales[j]);
assert(time <= crowdsale.startsAt());
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) public onlyOwner {
assert(address(_pricingStrategy) != address(0));
assert(address(pricingStrategy) == address(0));
pricingStrategy = _pricingStrategy;
// Don't allow setting bad agent
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
// Change
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else return State.Failure;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
//
// Modifiers
//
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function claimTokens(address _token) public onlyOwner {
require(_token != address(0));
ERC20Ext token = ERC20Ext(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
ClaimedTokens(_token, owner, balance);
}
//
// Abstract functions
//
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) public constant returns (bool limitBroken);
function isBreakingInvestorCap(address receiver, uint tokenAmount) public constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract MintedTokenCappedCrowdsaleExt is CrowdsaleExt2 {
uint public maximumSellableTokens;
address public salespool;
function MintedTokenCappedCrowdsaleExt(string _name,
address _token,
PricingStrategy _pricingStrategy,
address _multisigWallet,
uint _start, uint _end,
uint _minimumFundingGoal,
uint _maximumSellableTokens,
bool _isUpdatable,
bool _isWhiteListed) CrowdsaleExt2(_name, _token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal, _isUpdatable, _isWhiteListed) {
salespool = msg.sender;
maximumSellableTokens = _maximumSellableTokens;
}
// Crowdsale maximumSellableTokens has been changed
event MaximumSellableTokensChanged(uint newMaximumSellableTokens);
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) public constant returns (bool limitBroken) {
return tokensSoldTotal > maximumSellableTokens;
}
function isBreakingInvestorCap(address addr, uint tokenAmount) public constant returns (bool limitBroken) {
assert(isWhiteListed);
uint maxCap = earlyParticipantWhitelist[addr].maxCap;
return (tokenAmountOf[addr].plus(tokenAmount)) > maxCap;
}
function isCrowdsaleFull() public constant returns (bool) {
return tokensSold >= maximumSellableTokens;
}
function setMaximumSellableTokens(uint tokens) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
// assert(now <= startsAt);
CrowdsaleExt2 lastTierCntrct = CrowdsaleExt2(getLastTier());
assert(!lastTierCntrct.finalized());
maximumSellableTokens = tokens;
MaximumSellableTokensChanged(maximumSellableTokens);
}
function updateRate(uint newOneTokenInWei) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
// assert(now <= startsAt);
CrowdsaleExt2 lastTierCntrct = CrowdsaleExt2(getLastTier());
assert(!lastTierCntrct.finalized());
pricingStrategy.updateRate(newOneTokenInWei);
}
// set crowdsale token source address
function setSalesPool(address addr) public onlyOwner {
require(addr != 0x0);
salespool = addr;
}
function assignTokens(address receiver, uint tokenAmount) private {
token.transferFrom(salespool, receiver, tokenAmount);
}
}
| 222,166 | 13,093 |
074fb2e21fc9e3a30022aa3881c2dab31e0c3a0fb7cd91cf88f7cdc734f8efc1
| 22,329 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2d/2d2f49109ca13a9471d63a040929ceaec9a51971_PenguinBoosterRocket.sol
| 3,881 | 16,454 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) 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 Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using 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) + 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
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
modifier onlyOwner() {
require(owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(owner, address(0));
owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface IAllocationController {
function penguinTiers(address penguinAddress) external view returns(uint8);
function allocations(address penguinAddress) external view returns(uint256);
function totalAllocations() external view returns(uint256);
}
contract PenguinBoosterRocket is Ownable {
using SafeERC20 for IERC20;
//token for event
IERC20 public tokenForDistribution;
//token to be used for payment
IERC20 public tokenToPay;
//contract that can controls allocations
address public allocationController;
//amount of tokenToPay that buys an entire tokenForDistribution
uint256 public exchangeRateWholeToken;
//divisor for exchange rate. set in constructor equal to 10**decimals of tokenForDistribution
uint256 public immutable exchangeRateDivisor;
uint256 public immutable allocationRate;
//UTC timestamp of event start
uint256 public eventStart;
//UTC timestamp of event end
uint256 public eventEnd;
//set in BIPS. can be adjusted up to allow all addresses to purchase more tokens
uint256 public allocationMultiplierBIPS;
//tracks sum of all tokens sold
uint256 public totalTokensSold;
//tracks sum of proceeds collated in tokenToPay from all token sales
uint256 public totalProceeds;
//determines if exchange rate is adjustable or fixed
bool public adjustableExchangeRate;
//determines if start/end times can be adjusted, or if they are fixed
bool public adjustableTiming;
//determines if allocationMultiplierBIPS is adjustable or fixed at 1
bool public adjustableAllocationMultiplierBIPS;
//amount of tokens purchased by each address
mapping(address => uint256) public tokensPurchased;
//discount amounts for tiers in BIPS
uint256[5] public discountBIPS;
//Keeps track of wether a user has agreed to the terms and conditions or not.
mapping(address => bool) public hasAgreedToTermsAndConditions;
//special testing mapping
mapping(address => bool) public testingWhitelist;
event TokensPurchased(address indexed buyer, uint256 amountPurchased);
event ExchangeRateSet(uint256 newExchangeRate);
event AllocationMultiplierBIPSIncreased(uint256 newMultiplier);
event AgreedToTermsAndConditions(address userThatAgreed, bool hasAgreed, uint256 block_timestamp);
//checks to see if purchase is allowed
modifier checkPurchase(address buyer, uint256 amountToBuy) {
require(eventOngoing() || testingWhitelist[buyer],"event not ongoing");
require(canPurchase(buyer) >= amountToBuy, "you cannot buy this many tokens");
require(amountToBuy <= tokensLeftToDistribute(), "amountToBuy exceeds contract balance");
_;
}
constructor(IERC20 tokenForDistribution_,
IERC20 tokenToPay_,
uint256 eventStart_,
uint256 eventEnd_,
uint256 exchangeRateWholeToken_,
uint256 allocationRate_,
address allocationController_,
bool adjustableExchangeRate_,
bool adjustableTiming_,
bool adjustableAllocationMultiplierBIPS_) {
require(eventStart_ > block.timestamp, "event must start in future");
require(eventStart_ < eventEnd_, "event must start before it ends");
tokenForDistribution = tokenForDistribution_;
tokenToPay = tokenToPay_;
eventStart = eventStart_;
eventEnd = eventEnd_;
exchangeRateWholeToken = exchangeRateWholeToken_;
emit ExchangeRateSet(exchangeRateWholeToken_);
exchangeRateDivisor = 10**(tokenForDistribution.decimals());
allocationRate = allocationRate_; //REMINDER: this is scaled up by 1e18
allocationController = allocationController_;
adjustableExchangeRate = adjustableExchangeRate_;
adjustableTiming = adjustableTiming_;
adjustableAllocationMultiplierBIPS = adjustableAllocationMultiplierBIPS_;
allocationMultiplierBIPS = 10000; //starts as multiplier of 1
emit AllocationMultiplierBIPSIncreased(10000);
discountBIPS = [0, 0, 0, 0, 0];
}
//PUBLIC (VIEW) FUNCTIONS
function eventStarted() public view returns(bool) {
return(block.timestamp >= eventStart);
}
function eventEnded() public view returns(bool) {
return(block.timestamp > eventEnd);
}
function eventOngoing() public view returns(bool) {
return(eventStarted() && !eventEnded());
}
//get amount of tokens buyer can purchase
function canPurchase(address penguinAddress) public view returns(uint256) {
uint256 allocation = IAllocationController(allocationController).allocations(penguinAddress);
return(((allocation * allocationRate * allocationMultiplierBIPS) / 10000) / 1e18 - tokensPurchased[penguinAddress]);
}
//find amount of tokenToPay needed to buy amountToBuy of tokenForDistribution
function findAmountToPay(uint256 amountToBuy, address penguinAddress) public view returns(uint256) {
uint8 userTier = IAllocationController(allocationController).penguinTiers(penguinAddress);
if(userTier > 0) {
userTier -= 1;
}
uint256 discount = discountBIPS[userTier];
uint256 amountToPay = ((amountToBuy * exchangeRateWholeToken * (10000 - discount)) / 10000) / exchangeRateDivisor;
return amountToPay;
}
function tokensLeftToDistribute() public view returns(uint256) {
return tokenForDistribution.balanceOf(address(this));
}
function hasTheUserAgreed(address _user) public view returns(bool) {
return hasAgreedToTermsAndConditions[_user];
}
//PUBLIC FUNCTIONS
function agreeToTermsAndConditions() public {
if (hasAgreedToTermsAndConditions[msg.sender]){
return;
}
else {
hasAgreedToTermsAndConditions[msg.sender] = true;
emit AgreedToTermsAndConditions(msg.sender, hasAgreedToTermsAndConditions[msg.sender], block.timestamp);
}
}
//EXTERNAL FUNCTIONS
function purchaseTokens(uint256 amountToBuy) external checkPurchase(msg.sender, amountToBuy) {
agreeToTermsAndConditions();
require(amountToBuy > 0);
_processPurchase(msg.sender, amountToBuy);
}
//OWNER-ONLY FUNCTIONS
function adjustStart(uint256 newStartTime) external onlyOwner {
require(adjustableTiming, "timing is not adjustable");
require(!eventOngoing(), "cannot adjust start while event ongoing");
require(newStartTime < eventEnd, "event must start before it ends");
require(newStartTime > block.timestamp, "event must start in future");
eventStart = newStartTime;
}
function adjustEnd(uint256 newEndTime) external onlyOwner {
require(adjustableTiming, "timing is not adjustable");
require(eventStart < newEndTime, "event must start before it ends");
eventEnd = newEndTime;
}
function adjustExchangeRate(uint256 newExchangeRate) external onlyOwner {
require(adjustableExchangeRate, "exchange rate is not adjustable");
exchangeRateWholeToken = newExchangeRate;
emit ExchangeRateSet(newExchangeRate);
}
function increaseAllocationMultiplierBIPS(uint256 newAllocationMultiplierBIPS) external onlyOwner {
require(adjustableAllocationMultiplierBIPS, "allocationMultiplierBIPS is not adjustable");
require(newAllocationMultiplierBIPS > allocationMultiplierBIPS, "can only increase multiplier");
allocationMultiplierBIPS = newAllocationMultiplierBIPS;
emit AllocationMultiplierBIPSIncreased(newAllocationMultiplierBIPS);
}
function withdrawDistributionProceeds(address dest) external onlyOwner {
uint256 toSend = tokenToPay.balanceOf(address(this));
tokenToPay.safeTransfer(dest, toSend);
}
function withdrawUnsoldTokens(address dest) external onlyOwner {
uint256 toSend = tokenForDistribution.balanceOf(address(this));
tokenForDistribution.safeTransfer(dest, toSend);
}
function addToTestingWhitelist(address tester) external onlyOwner {
testingWhitelist[tester] = true;
}
//INTERNAL FUNCTIONS
function _processPurchase(address penguinAddress, uint256 amountToBuy) internal {
uint256 amountToPay = findAmountToPay(amountToBuy, penguinAddress);
totalProceeds += amountToPay;
tokenForDistribution.safeTransfer(penguinAddress, amountToBuy);
totalTokensSold += amountToBuy;
tokensPurchased[penguinAddress] += amountToBuy;
emit TokensPurchased(penguinAddress, amountToBuy);
tokenToPay.safeTransferFrom(penguinAddress, address(this), amountToPay);
}
}
| 90,293 | 13,094 |
52959899efd0acad03fa9d3a06e6b43e70f2b22448b1c3bdc4161775db12fcbe
| 9,316 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xd6dbc68ffe25b456a338c2df645e75f7c3a19db7.sol
| 2,265 | 8,654 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
/// @title Role based access control mixin for Rasmart Platform
/// @author Mai Abha <maiabha82@gmail.com>
/// @dev Ignore DRY approach to achieve readability
contract RBACMixin {
/// @notice Constant string message to throw on lack of access
string constant FORBIDDEN = "Haven't enough right to access";
/// @notice Public map of owners
mapping (address => bool) public owners;
/// @notice Public map of minters
mapping (address => bool) public minters;
/// @notice The event indicates the addition of a new owner
/// @param who is address of added owner
event AddOwner(address indexed who);
/// @notice The event indicates the deletion of an owner
/// @param who is address of deleted owner
event DeleteOwner(address indexed who);
/// @notice The event indicates the addition of a new minter
/// @param who is address of added minter
event AddMinter(address indexed who);
/// @notice The event indicates the deletion of a minter
/// @param who is address of deleted minter
event DeleteMinter(address indexed who);
constructor () public {
_setOwner(msg.sender, true);
}
/// @notice The functional modifier rejects the interaction of senders who are not owners
modifier onlyOwner() {
require(isOwner(msg.sender), FORBIDDEN);
_;
}
/// @notice Functional modifier for rejecting the interaction of senders that are not minters
modifier onlyMinter() {
require(isMinter(msg.sender), FORBIDDEN);
_;
}
/// @notice Look up for the owner role on providen address
/// @param _who is address to look up
/// @return A boolean of owner role
function isOwner(address _who) public view returns (bool) {
return owners[_who];
}
/// @notice Look up for the minter role on providen address
/// @param _who is address to look up
/// @return A boolean of minter role
function isMinter(address _who) public view returns (bool) {
return minters[_who];
}
/// @notice Adds the owner role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function addOwner(address _who) public onlyOwner returns (bool) {
_setOwner(_who, true);
}
/// @notice Deletes the owner role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to delete role
/// @return A boolean that indicates if the operation was successful.
function deleteOwner(address _who) public onlyOwner returns (bool) {
_setOwner(_who, false);
}
/// @notice Adds the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function addMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, true);
}
/// @notice Deletes the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to delete role
/// @return A boolean that indicates if the operation was successful.
function deleteMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, false);
}
/// @notice Changes the owner role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setOwner(address _who, bool _flag) private returns (bool) {
require(owners[_who] != _flag);
owners[_who] = _flag;
if (_flag) {
emit AddOwner(_who);
} else {
emit DeleteOwner(_who);
}
return true;
}
/// @notice Changes the minter role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setMinter(address _who, bool _flag) private returns (bool) {
require(minters[_who] != _flag);
minters[_who] = _flag;
if (_flag) {
emit AddMinter(_who);
} else {
emit DeleteMinter(_who);
}
return true;
}
}
interface IMintableToken {
function mint(address _to, uint256 _amount) external returns (bool);
}
/// @title Very simplified implementation of Token Bucket Algorithm to secure token minting
/// @author Mai Abha <maiabha82@gmail.com>
/// @notice Works with tokens implemented Mintable interface
/// @dev Transfer ownership/minting role to contract and execute mint over TeamBucket proxy to secure
contract TeamBucket is RBACMixin, IMintableToken {
using SafeMath for uint;
/// @notice Limit maximum amount of available for minting tokens when bucket is full
uint256 public size;
/// @notice Bucket refill rate
uint256 public rate;
/// @notice Stored time of latest minting
/// @dev Each successful call of minting function will update field with call timestamp
uint256 public lastMintTime;
/// @notice Left tokens in bucket on time of latest minting
uint256 public leftOnLastMint;
/// @notice Reference of Mintable token
/// @dev Setup in contructor phase and never change in future
IMintableToken public token;
/// @notice Token Bucket leak event fires on each minting
/// @param to is address of target tokens holder
/// @param left is amount of tokens available in bucket after leak
event Leak(address indexed to, uint256 left);
/// @param _token is address of Mintable token
/// @param _size initial size of token bucket
/// @param _rate initial refill rate (tokens/sec)
constructor (address _token, uint256 _size, uint256 _rate) public {
token = IMintableToken(_token);
size = _size;
rate = _rate;
leftOnLastMint = _size;
}
/// @notice Change size of bucket
/// @dev Require owner role to call
/// @param _size is new size of bucket
/// @return A boolean that indicates if the operation was successful.
function setSize(uint256 _size) public onlyOwner returns (bool) {
size = _size;
return true;
}
/// @notice Change refill rate of bucket
/// @dev Require owner role to call
/// @param _rate is new refill rate of bucket
/// @return A boolean that indicates if the operation was successful.
function setRate(uint256 _rate) public onlyOwner returns (bool) {
rate = _rate;
return true;
}
/// @notice Change size and refill rate of bucket
/// @dev Require owner role to call
/// @param _size is new size of bucket
/// @param _rate is new refill rate of bucket
/// @return A boolean that indicates if the operation was successful.
function setSizeAndRate(uint256 _size, uint256 _rate) public onlyOwner returns (bool) {
return setSize(_size) && setRate(_rate);
}
/// @notice Function to mint tokens
/// @param _to The address that will receive the minted tokens.
/// @param _amount The amount of tokens to mint.
/// @return A boolean that indicates if the operation was successful.
function mint(address _to, uint256 _amount) public onlyMinter returns (bool) {
uint256 available = availableTokens();
require(_amount <= available);
leftOnLastMint = available.sub(_amount);
lastMintTime = now; // solium-disable-line security/no-block-members
require(token.mint(_to, _amount));
return true;
}
/// @notice Function to calculate and get available in bucket tokens
/// @return An amount of available tokens in bucket
function availableTokens() public view returns (uint) {
// solium-disable-next-line security/no-block-members
uint256 timeAfterMint = now.sub(lastMintTime);
uint256 refillAmount = rate.mul(timeAfterMint).add(leftOnLastMint);
return size < refillAmount ? size : refillAmount;
}
}
| 219,906 | 13,095 |
401872c1555ba4b3a19eb8f1c10675b803f196452df835b762906b8ea969f3aa
| 29,196 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/92/9217fc8240f11F547d6F857b78767E945aDc1195_GLP.sol
| 4,397 | 17,720 |
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IYieldTracker {
function claim(address _account, address _receiver) external returns (uint256);
function updateRewards(address _account) external;
function getTokensPerInterval() external view returns (uint256);
function claimable(address _account) external view returns (uint256);
}
interface IBaseToken {
function totalStaked() external view returns (uint256);
function stakedBalance(address _account) external view returns (uint256);
function removeAdmin(address _account) external;
function setInPrivateTransferMode(bool _inPrivateTransferMode) external;
function withdrawToken(address _token, address _account, uint256 _amount) external;
}
contract BaseToken is IERC20, IBaseToken {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public override totalSupply;
uint256 public nonStakingSupply;
address public gov;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
address[] public yieldTrackers;
mapping (address => bool) public nonStakingAccounts;
mapping (address => bool) public admins;
bool public inPrivateTransferMode;
mapping (address => bool) public isHandler;
modifier onlyGov() {
require(msg.sender == gov, "BaseToken: forbidden");
_;
}
modifier onlyAdmin() {
require(admins[msg.sender], "BaseToken: forbidden");
_;
}
constructor(string memory _name, string memory _symbol, uint256 _initialSupply) public {
name = _name;
symbol = _symbol;
gov = msg.sender;
_mint(msg.sender, _initialSupply);
}
function setGov(address _gov) external onlyGov {
gov = _gov;
}
function setInfo(string memory _name, string memory _symbol) external onlyGov {
name = _name;
symbol = _symbol;
}
function setYieldTrackers(address[] memory _yieldTrackers) external onlyGov {
yieldTrackers = _yieldTrackers;
}
function addAdmin(address _account) external onlyGov {
admins[_account] = true;
}
function removeAdmin(address _account) external override onlyGov {
admins[_account] = false;
}
// to help users who accidentally send their tokens to this contract
function withdrawToken(address _token, address _account, uint256 _amount) external override onlyGov {
IERC20(_token).safeTransfer(_account, _amount);
}
function setInPrivateTransferMode(bool _inPrivateTransferMode) external override onlyGov {
inPrivateTransferMode = _inPrivateTransferMode;
}
function setHandler(address _handler, bool _isActive) external onlyGov {
isHandler[_handler] = _isActive;
}
function addNonStakingAccount(address _account) external onlyAdmin {
require(!nonStakingAccounts[_account], "BaseToken: _account already marked");
_updateRewards(_account);
nonStakingAccounts[_account] = true;
nonStakingSupply = nonStakingSupply.add(balances[_account]);
}
function removeNonStakingAccount(address _account) external onlyAdmin {
require(nonStakingAccounts[_account], "BaseToken: _account not marked");
_updateRewards(_account);
nonStakingAccounts[_account] = false;
nonStakingSupply = nonStakingSupply.sub(balances[_account]);
}
function recoverClaim(address _account, address _receiver) external onlyAdmin {
for (uint256 i = 0; i < yieldTrackers.length; i++) {
address yieldTracker = yieldTrackers[i];
IYieldTracker(yieldTracker).claim(_account, _receiver);
}
}
function claim(address _receiver) external {
for (uint256 i = 0; i < yieldTrackers.length; i++) {
address yieldTracker = yieldTrackers[i];
IYieldTracker(yieldTracker).claim(msg.sender, _receiver);
}
}
function totalStaked() external view override returns (uint256) {
return totalSupply.sub(nonStakingSupply);
}
function balanceOf(address _account) external view override returns (uint256) {
return balances[_account];
}
function stakedBalance(address _account) external view override returns (uint256) {
if (nonStakingAccounts[_account]) {
return 0;
}
return balances[_account];
}
function transfer(address _recipient, uint256 _amount) external override returns (bool) {
_transfer(msg.sender, _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(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _sender, address _recipient, uint256 _amount) external override returns (bool) {
if (isHandler[msg.sender]) {
_transfer(_sender, _recipient, _amount);
return true;
}
uint256 nextAllowance = allowances[_sender][msg.sender].sub(_amount, "BaseToken: transfer amount exceeds allowance");
_approve(_sender, msg.sender, nextAllowance);
_transfer(_sender, _recipient, _amount);
return true;
}
function _mint(address _account, uint256 _amount) internal {
require(_account != address(0), "BaseToken: mint to the zero address");
_updateRewards(_account);
totalSupply = totalSupply.add(_amount);
balances[_account] = balances[_account].add(_amount);
if (nonStakingAccounts[_account]) {
nonStakingSupply = nonStakingSupply.add(_amount);
}
emit Transfer(address(0), _account, _amount);
}
function _burn(address _account, uint256 _amount) internal {
require(_account != address(0), "BaseToken: burn from the zero address");
_updateRewards(_account);
balances[_account] = balances[_account].sub(_amount, "BaseToken: burn amount exceeds balance");
totalSupply = totalSupply.sub(_amount);
if (nonStakingAccounts[_account]) {
nonStakingSupply = nonStakingSupply.sub(_amount);
}
emit Transfer(_account, address(0), _amount);
}
function _transfer(address _sender, address _recipient, uint256 _amount) private {
require(_sender != address(0), "BaseToken: transfer from the zero address");
require(_recipient != address(0), "BaseToken: transfer to the zero address");
if (inPrivateTransferMode) {
require(isHandler[msg.sender], "BaseToken: msg.sender not whitelisted");
}
_updateRewards(_sender);
_updateRewards(_recipient);
balances[_sender] = balances[_sender].sub(_amount, "BaseToken: transfer amount exceeds balance");
balances[_recipient] = balances[_recipient].add(_amount);
if (nonStakingAccounts[_sender]) {
nonStakingSupply = nonStakingSupply.sub(_amount);
}
if (nonStakingAccounts[_recipient]) {
nonStakingSupply = nonStakingSupply.add(_amount);
}
emit Transfer(_sender, _recipient,_amount);
}
function _approve(address _owner, address _spender, uint256 _amount) private {
require(_owner != address(0), "BaseToken: approve from the zero address");
require(_spender != address(0), "BaseToken: approve to the zero address");
allowances[_owner][_spender] = _amount;
emit Approval(_owner, _spender, _amount);
}
function _updateRewards(address _account) private {
for (uint256 i = 0; i < yieldTrackers.length; i++) {
address yieldTracker = yieldTrackers[i];
IYieldTracker(yieldTracker).updateRewards(_account);
}
}
}
interface IMintable {
function isMinter(address _account) external returns (bool);
function setMinter(address _minter, bool _isActive) external;
function mint(address _account, uint256 _amount) external;
function burn(address _account, uint256 _amount) external;
}
contract MintableBaseToken is BaseToken, IMintable {
mapping (address => bool) public override isMinter;
constructor(string memory _name, string memory _symbol, uint256 _initialSupply) public BaseToken(_name, _symbol, _initialSupply) {
}
modifier onlyMinter() {
require(isMinter[msg.sender], "MintableBaseToken: forbidden");
_;
}
function setMinter(address _minter, bool _isActive) external override onlyGov {
isMinter[_minter] = _isActive;
}
function mint(address _account, uint256 _amount) external override onlyMinter {
_mint(_account, _amount);
}
function burn(address _account, uint256 _amount) external override onlyMinter {
_burn(_account, _amount);
}
}
contract GLP is MintableBaseToken {
constructor() public MintableBaseToken("MMY LP", "MLP", 0) {
}
function id() external pure returns (string memory _name) {
return "MLP";
}
}
| 333,649 | 13,096 |
f6cda5037b3b5bf0ac31cd1768109d597ec826a19f0a552344148da918773dc5
| 23,535 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFxznGmEVdp5XxnQnyGp2FhFfBkMAprveW_FireFullContract.sol
| 5,986 | 23,017 |
//SourceUnit: FireFullContract.sol
pragma solidity ^0.5.3;
contract Ownable {
mapping(address => bool) public owners;
address public creater;
constructor() public {
owners[msg.sender] = true;
creater = msg.sender;
}
modifier onlyOwner() {
require(owners[msg.sender] == true,'Permission denied');
_;
}
modifier onlyCreater() {
require(creater == msg.sender,'Permission denied');
_;
}
function addOwnership(address _newOwner) public onlyOwner {
owners[_newOwner] = true;
}
function delOwnership(address _newOwner) public onlyOwner {
owners[_newOwner] = false;
}
}
library SafeMath {
function mul(uint _a, uint _b) internal pure returns (uint 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;
require(c / _a == _b,'mul error');
return c;
}
function div(uint _a, uint _b) internal pure returns (uint) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint _a, uint _b) internal pure returns (uint) {
require(_b <= _a,'sub error');
return _a - _b;
}
function add(uint _a, uint _b) internal pure returns (uint c) {
c = _a + _b;
require(c >= _a,'add error');
return c;
}
}
interface FirePowerToken {
function saleScale() external view returns (uint);
function balanceOf(address _owner) external view returns (uint) ;
function burn(address _from, uint _value) external returns (bool);
function totalSupply() external view returns (uint);
function getSP(address _account) view external returns(bool,uint,uint);
}
contract FFGModel{
struct playerObj{
bool state;
bool joinState;
uint input;
uint output;
uint nomalMax;
uint totalProfit;
uint nomalProfit;
uint teamProfit;
uint jackpotProfit;
uint contractBalance;
address[] invit;
uint[] recommand;
uint teamJoin;
bool isSP;
}
struct jackpotObj{
uint pool;
uint water;
uint scale;
}
struct superPlayerObj{
bool isActive;
uint profit;
uint profitFlag;
uint teamPlayers;
}
}
contract FFGConfig is FFGModel{
address public firePowerContract = 0xD0F8eB83a6917092f37CfC5ae3c9eaD3624854fd;
FirePowerToken internal token = FirePowerToken(firePowerContract);
uint public periods = 1;
uint public totalJoin = 0;
uint public sedimentaryAsset = 0;
uint public playerCounter = 0;
uint public minJoinAmount = 2000 trx;
uint[] public rewardScale = new uint[](10);
uint public jackpotIndex = 1;
uint public nomalListIndex = 0;
bool public contractState = false;
address[] public nomalList = new address[](5);
address payable[] public retainAddress = new address payable[](2);
event WithdrawEvent(address indexed _player,uint _amount,uint time);
event InvitEvent(address indexed _from,address _player,uint time);
event JoinEvent(address indexed _player,uint _joinAmount,uint time);
event ProfitEvent(address indexed _player,uint _rewardAmount,uint time);
event TeamRewardEvent(address indexed _player,address _invit,uint _level, uint _rewardAmount,uint time);
event PrizeEvent(address indexed _player,uint _jackpot,uint _prize,uint _amount,uint time);
event SuperPlayerEvent(address indexed _player,uint _total,uint _amount,uint time);
event leaveContractEvent(address indexed _player,uint _output,uint time);
mapping(uint=>jackpotObj) public jackpot;
mapping(address => superPlayerObj) public superPlayerList;
mapping(address => playerObj) public players;
mapping(uint => address) public joinPlayerList;
function periodsLimit() public view returns(uint){
if(periods == 1){
return 50000 trx;
}else if(periods == 2){
return 100000 trx;
}else{
return 200000 trx;
}
}
function joinScale() public view returns(uint){
if(periods == 1){
return 26;
}else if(periods == 2){
return 30;
}else{
return 36;
}
}
modifier isHuman() {
address _addr = msg.sender;
uint _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
}
contract FireFullContract is FFGConfig,Ownable{
using SafeMath for uint;
function join() payable external{
require(contractState,'Contract Not Start');
require(msg.value <= periodsLimit(),'Period Maxmum limit exceeded');
require(msg.value >= minJoinAmount,'Period Minimum limit exceeded');
require(players[msg.sender].state,'Please bind the recommender in advance');
uint scale = joinScale();
uint profit = msg.value.mul(scale).div(10);
uint ticketScale = token.saleScale();
uint ticket = msg.value.mul(100).div(ticketScale);
uint tokenBalance = token.balanceOf(msg.sender);
require(tokenBalance >= ticket,'ticket not enough');
contractReward(msg.value.mul(35).div(100));
joinPlayerList[playerCounter] = msg.sender;
playerCounter = playerCounter + 1;
totalJoin = totalJoin.add(msg.value);
if(nomalListIndex < 5){
nomalList[nomalListIndex] = msg.sender;
nomalListIndex++;
}
playerObj memory player = players[msg.sender];
if(player.joinState == true){
require(player.input.add(msg.value) <= periodsLimit(),'Period Maxmum limit exceeded');
uint _scale = player.output.mul(10).div(player.input);
player.input = player.input.add(msg.value);
player.output = player.input.mul(_scale).div(10);
player.nomalMax = player.input.mul(11).div(10);
}else{
player.input = msg.value;
player.output = profit;
player.totalProfit = 0;
player.nomalProfit = 0;
player.teamProfit = 0;
player.joinState = true;
player.nomalMax = msg.value.mul(11).div(10);
players[player.invit[0]].recommand[0]+=1;
updateSPTeam(true,player.invit);
}
players[msg.sender] = player;
teamReward();
joinJackpot();
token.burn(msg.sender,ticket);
retainAddress[0].transfer(msg.value.div(100));
retainAddress[1].transfer(msg.value.div(50));
emit JoinEvent(msg.sender,msg.value,now);
}
function restore(address _playerAddress,address _invitAddress,uint _timeStamp) external onlyOwner{
require(players[_invitAddress].state,'recommender not exist');
require(!players[_playerAddress].state,'Player already exists');
address[] memory myinvit = new address[](10);
myinvit[0] = _invitAddress;
players[_invitAddress].recommand[1]+=1;
for(uint i = 0;i<9;i++){
if(players[_invitAddress].invit[i]!=address(0x0)){
myinvit[i+1] = players[_invitAddress].invit[i];
players[players[_invitAddress].invit[i]].recommand[i+2]+=1;
}else{
break;
}
}
players[_playerAddress] = playerObj({
state:true,
joinState:false,
input:0,
nomalMax:0,
output:0,
totalProfit:0,
nomalProfit:0,
teamProfit:0,
contractBalance:0,
invit:myinvit,
recommand:new uint[](11),
jackpotProfit:0,
teamJoin:0,
isSP:false
});
emit InvitEvent(_invitAddress,_playerAddress,_timeStamp);
}
function setFirePowerContract(address _firePowerContract) external onlyOwner returns(bool){
firePowerContract = _firePowerContract;
token = FirePowerToken(firePowerContract);
return true;
}
function setMinJoinAmount(uint _amount) external onlyOwner returns (bool){
minJoinAmount = _amount;
return true;
}
function updateSPTeam(bool addOrSub,address[] memory invit) internal{
for(uint i = 0;i < invit.length; i++){
if(invit[i] != address(0x0)){
if(players[invit[i]].isSP){
if(addOrSub){
superPlayerList[invit[i]].teamPlayers = superPlayerList[invit[i]].teamPlayers + 1;
}else{
superPlayerList[invit[i]].teamPlayers = superPlayerList[invit[i]].teamPlayers - 1;
}
return;
}
}
}
}
function withdraw() external isHuman{
uint balance = players[msg.sender].contractBalance;
players[msg.sender].contractBalance = 0;
msg.sender.transfer(balance);
emit WithdrawEvent(msg.sender,balance,now);
}
function sedimentaryAssetWithdraw() external onlyOwner{
require(sedimentaryAsset >= 0,'sedimentary asset not enoug');
uint withdrawAmount = sedimentaryAsset;
sedimentaryAsset = 0;
msg.sender.transfer(withdrawAmount);
}
function contractReward(uint _amount) internal {
uint maxPlayer = nomalListIndex < 5?nomalListIndex:5;
uint reward = _amount;
if(maxPlayer == 0){
sedimentaryAsset = sedimentaryAsset.add(reward);
return;
}
reward = reward.div(maxPlayer);
address player_add;
playerObj memory player;
uint _reward;
bool haveNext = true;
uint surplus = 0;
uint player_reward = 0;
bool leave;
for(uint i = 0;i<maxPlayer;i++){
player_add = nomalList[i];
if(haveNext && player_add == address(0x0)){
findNextNomal(i);
if(nomalList[i] == address(0x0)){
haveNext = false;
surplus = surplus.add(reward);
continue;
}else{
player_add = nomalList[i];
}
}
surplus = reward.add(surplus);
do{
_reward = surplus;
player = players[player_add];
player_reward = surplus;
surplus = 0;
if(player.nomalProfit.add(player_reward) >= player.nomalMax){
player_reward = player.nomalMax - player.nomalProfit;
player.nomalProfit = player.nomalMax;
leave = true;
}else{
player.nomalProfit = player.nomalProfit.add(player_reward);
}
if(player.totalProfit.add(player_reward) >= player.output){
player_reward = player.output - player.totalProfit;
player.totalProfit = player.output;
leave = true;
leaveContract(player,player_add,true);
}else{
player.totalProfit = player.totalProfit.add(player_reward);
}
if(player_reward > 0){
player.contractBalance = player.contractBalance.add(player_reward);
players[player_add] = player;
emit ProfitEvent(player_add,player_reward,now);
}
if(leave){
if(_reward.sub(player_reward) > 0){
surplus = _reward.sub(player_reward);
}else{
break;
}
if(haveNext){
findNextNomal(i);
if(nomalList[i] == address(0x0)){
haveNext = false;
break;
}else{
player_add = nomalList[i];
}
}else{
break;
}
}else{
break;
}
}while(true);
}
if(surplus > 0){
sedimentaryAsset = sedimentaryAsset.add(surplus);
}
}
function findNextNomal(uint nomalIndex) internal{
address next;
uint index = nomalListIndex;
do{
next = joinPlayerList[index];
index++;
if(index > playerCounter){
index = nomalListIndex;
break;
}
}while(players[next].joinState == false);
nomalList[nomalIndex] = next;
nomalListIndex = index;
}
function teamReward() internal{
address[] memory myInvit = players[msg.sender].invit;
uint reward;
uint needRecommand;
uint split;
playerObj memory invitPlayer;
for(uint i = 0;i < myInvit.length;i++){
invitPlayer = players[myInvit[i]];
reward = msg.value.mul(rewardScale[i]).div(100);
if(myInvit[i] == address(0x0) || invitPlayer.joinState == false){
sedimentaryAsset = sedimentaryAsset.add(reward);
continue;
}
invitPlayer.teamJoin = invitPlayer.teamJoin.add(msg.value);
needRecommand = (i+1)/2 + (i+1)%2;
if(invitPlayer.recommand[0] >= needRecommand && invitPlayer.joinState == true){
invitPlayer.totalProfit = invitPlayer.totalProfit.add(reward);
if(invitPlayer.totalProfit > invitPlayer.output){
split = invitPlayer.totalProfit.sub(invitPlayer.output);
reward = reward.sub(split);
if(split > 0){
sedimentaryAsset = sedimentaryAsset.add(split);
}
invitPlayer.totalProfit = invitPlayer.output;
}
invitPlayer.teamProfit = invitPlayer.teamProfit.add(reward);
invitPlayer.contractBalance = invitPlayer.contractBalance.add(reward);
emit TeamRewardEvent(myInvit[i],msg.sender,i+1, reward,now);
}else{
sedimentaryAsset = sedimentaryAsset.add(reward);
}
players[myInvit[i]] = invitPlayer;
if(invitPlayer.totalProfit == invitPlayer.output){
leaveContract(invitPlayer,myInvit[i],true);
}
}
}
function leaveContract(playerObj memory player,address _player,bool find) internal{
if(player.totalProfit >= player.output && player.joinState == true){
if(find){
for(uint k = 0; k<5;k++){
if(nomalList[k] == _player){
findNextNomal(k);
}
}
}
player.joinState = false;
if(player.invit[0] != address(0x0)){
players[player.invit[0]].recommand[0] -= 1;
}
updateSPTeam(false,player.invit);
players[_player] = player;
emit leaveContractEvent(_player,player.totalProfit,now);
}
}
function joinJackpot() internal{
uint input = msg.value.mul(15).div(100);
if(jackpot[jackpotIndex].water.add(input) >= jackpot[jackpotIndex].pool){
if(jackpot[jackpotIndex].water.add(input) > jackpot[jackpotIndex].pool){
uint split = jackpot[jackpotIndex].water.add(input).sub(jackpot[jackpotIndex].pool);
jackpot[jackpotIndex].water = jackpot[jackpotIndex].pool;
drawJackpot(split);
}else{
jackpot[jackpotIndex].water = jackpot[jackpotIndex].pool;
drawJackpot(0);
}
}else{
jackpot[jackpotIndex].water = jackpot[jackpotIndex].water.add(input);
}
}
function nextJackpot() internal view returns(uint){
if(jackpotIndex < 5){
return jackpotIndex + 1;
}else{
return 1;
}
}
function drawJackpot(uint surplus) internal{
if(jackpot[jackpotIndex].water == jackpot[jackpotIndex].pool){
uint reward = jackpot[jackpotIndex].water.mul(jackpot[jackpotIndex].scale).div(100);
uint index = 1;
uint _reward = 0;
uint _prize = 0;
playerObj memory player;
for(uint i = playerCounter-1;i >= playerCounter.sub(32);i--){
if(index == 1){
_reward = reward.mul(45).div(100);
_prize = 1;
}else if(index > 1 && index <= 11){
_reward = reward.mul(20).div(1000);
_prize = 2;
}else if(index > 11 && index <= 31){
_reward = reward.mul(35).div(2000);
_prize = 3;
}else{
break;
}
player = players[joinPlayerList[i]];
player.contractBalance = player.contractBalance.add(_reward);
player.jackpotProfit = player.jackpotProfit.add(_reward);
if(player.totalProfit.add(_reward) >= player.output){
player.totalProfit = player.output;
}else{
player.totalProfit = player.totalProfit.add(_reward);
}
players[joinPlayerList[i]] = player;
leaveContract(player,joinPlayerList[i],true);
emit PrizeEvent(joinPlayerList[i],jackpot[jackpotIndex].pool,_prize,_reward,now);
index++;
}
uint split = jackpot[jackpotIndex].water.sub(reward);
jackpotIndex = nextJackpot();
if(jackpotIndex == 1){
initJackpot();
}
jackpot[jackpotIndex].water = split.add(surplus);
}
}
function superPlayerWithdraw() external isHuman{
require(players[msg.sender].isSP,"You're not a super player");
require(superPlayerList[msg.sender].teamPlayers >= 40,"Team players not enough");
uint flag = totalJoin.sub(superPlayerList[msg.sender].profitFlag);
require(flag > 0,"You don't have any new profit yet");
superPlayerList[msg.sender].profitFlag = totalJoin;
uint profit = flag.mul(5).div(10000);
superPlayerList[msg.sender].profit = superPlayerList[msg.sender].profit.add(profit);
msg.sender.transfer(profit);
emit SuperPlayerEvent(msg.sender,flag,profit,now);
}
function superPlayerProfit() external view returns(uint){
uint flag = totalJoin.sub(superPlayerList[msg.sender].profitFlag);
return flag.mul(5).div(10000);
}
function initJackpot() internal{
jackpot[1] = jackpotObj({pool:1500000 trx,water:0,scale:60});
jackpot[2] = jackpotObj({pool:3000000 trx,water:0,scale:60});
jackpot[3] = jackpotObj({pool:4500000 trx,water:0,scale:60});
jackpot[4] = jackpotObj({pool:6000000 trx,water:0,scale:60});
jackpot[5] = jackpotObj({pool:7500000 trx,water:0,scale:90});
}
function startContract() external {
require(msg.sender == firePowerContract,'startContract error');
if(!contractState){
contractState = true;
}
}
function activateSuperPlayer() external returns(bool){
require(players[msg.sender].isSP == false,'SuperPlayer Activated');
(bool state,,) = token.getSP(msg.sender);
if(state){
superPlayerList[msg.sender] = superPlayerObj({
isActive:true,
profit:0,
profitFlag:0,
teamPlayers:0
});
players[msg.sender].isSP = true;
return true;
}
return false;
}
constructor(address payable _address1,address payable _address2) public {
retainAddress[0] = _address1;
retainAddress[1] = _address2;
initJackpot();
uint[] memory t_scale = new uint[](10);
t_scale[0] = 10;
t_scale[1] = 8;
t_scale[2] = 7;
t_scale[3] = 2;
t_scale[4] = 1;
t_scale[5] = 1;
t_scale[6] = 1;
t_scale[7] = 2;
t_scale[8] = 4;
t_scale[9] = 6;
rewardScale = t_scale;
players[msg.sender] = playerObj({
state:true,
joinState:false,
input:0,
nomalMax:0,
output:0,
totalProfit:0,
nomalProfit:0,
teamProfit:0,
contractBalance:0,
invit:new address[](10),
recommand:new uint[](11),
jackpotProfit:0,
teamJoin:0,
isSP:false
});
}
function preShip(address _invit) external {
require(players[_invit].state,'recommender not exist');
require(!players[msg.sender].state,'Player already exists');
address[] memory myinvit = new address[](10);
myinvit[0] = _invit;
players[_invit].recommand[1]+=1;
for(uint i = 0;i<9;i++){
if(players[_invit].invit[i]!=address(0x0)){
myinvit[i+1] = players[_invit].invit[i];
players[players[_invit].invit[i]].recommand[i+2]+=1;
}else{
break;
}
}
players[msg.sender] = playerObj({
state:true,
joinState:false,
input:0,
nomalMax:0,
output:0,
totalProfit:0,
nomalProfit:0,
teamProfit:0,
contractBalance:0,
invit:myinvit,
recommand:new uint[](11),
jackpotProfit:0,
teamJoin:0,
isSP:false
});
emit InvitEvent(_invit,msg.sender,now);
}
function setNextPeriods() external {
require(msg.sender == firePowerContract,'No authority');
periods ++;
}
function contractInfo() external view returns(bool,uint,uint,uint,uint){
return (contractState,periodsLimit(),minJoinAmount,jackpot[jackpotIndex].pool,jackpot[jackpotIndex].water);
}
function jackpotInfo() external view returns(uint,uint,uint,uint,uint,uint,uint,uint,uint,uint){
return (jackpot[1].pool,jackpot[1].water,jackpot[2].pool,jackpot[2].water,jackpot[3].pool,jackpot[3].water,jackpot[4].pool,jackpot[4].water,jackpot[5].pool,jackpot[5].water);
}
function contractIndexInfo() external view returns(bool,uint,uint){
return (contractState,periods,totalJoin);
}
function contractPlayerInfo(address _address) view external returns(address[] memory, uint[] memory){
return (players[_address].invit,players[_address].recommand);
}
}
| 296,251 | 13,097 |
f5bfc4c7cea2dfea72f1590bbaa2b3d2fdc9187609703510616e4dc65ce9add9
| 24,427 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a4/a4580c04c067aae31489172d251e040990f00f49_TaxOfficeV2.sol
| 4,176 | 16,303 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
interface ITaxable {
function setTaxTiersTwap(uint8 _index, uint256 _value) external returns (bool);
function setTaxTiersRate(uint8 _index, uint256 _value) external returns (bool);
function enableAutoCalculateTax() external;
function disableAutoCalculateTax() external;
function setTaxCollectorAddress(address _taxCollectorAddress) external;
function isAddressExcluded(address _address) external returns (bool);
function setTaxRate(uint256 _taxRate) external;
function setBurnThreshold(uint256 _burnThreshold) external;
function excludeAddress(address _address) external returns (bool);
function includeAddress(address _address) external returns (bool);
function setRocketOracle(address _rocketOracle) external;
function setTaxOffice(address _taxOffice) external;
function taxRate() external view returns (uint256);
}
interface IUniswapV2Router {
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);
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 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 TaxOfficeV2 is Operator {
using SafeMath for uint256;
address public rocket = address(0xaD90E021dCE192181078A38402983C50BDCd9E34);
address public wftm = address(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
address public uniRouter = address(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
mapping(address => bool) public taxExclusionEnabled;
function setTaxTiersTwap(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(rocket).setTaxTiersTwap(_index, _value);
}
function setTaxTiersRate(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(rocket).setTaxTiersRate(_index, _value);
}
function enableAutoCalculateTax() public onlyOperator {
ITaxable(rocket).enableAutoCalculateTax();
}
function disableAutoCalculateTax() public onlyOperator {
ITaxable(rocket).disableAutoCalculateTax();
}
function setTaxRate(uint256 _taxRate) public onlyOperator {
ITaxable(rocket).setTaxRate(_taxRate);
}
function setBurnThreshold(uint256 _burnThreshold) public onlyOperator {
ITaxable(rocket).setBurnThreshold(_burnThreshold);
}
function setTaxCollectorAddress(address _taxCollectorAddress) public onlyOperator {
ITaxable(rocket).setTaxCollectorAddress(_taxCollectorAddress);
}
function excludeAddressFromTax(address _address) external onlyOperator returns (bool) {
return _excludeAddressFromTax(_address);
}
function _excludeAddressFromTax(address _address) private returns (bool) {
if (!ITaxable(rocket).isAddressExcluded(_address)) {
return ITaxable(rocket).excludeAddress(_address);
}
}
function includeAddressInTax(address _address) external onlyOperator returns (bool) {
return _includeAddressInTax(_address);
}
function _includeAddressInTax(address _address) private returns (bool) {
if (ITaxable(rocket).isAddressExcluded(_address)) {
return ITaxable(rocket).includeAddress(_address);
}
}
function taxRate() external view returns (uint256) {
return ITaxable(rocket).taxRate();
}
function addLiquidityTaxFree(address token,
uint256 amtRocket,
uint256 amtToken,
uint256 amtRocketMin,
uint256 amtTokenMin)
external
returns (uint256,
uint256,
uint256)
{
require(amtRocket != 0 && amtToken != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(rocket).transferFrom(msg.sender, address(this), amtRocket);
IERC20(token).transferFrom(msg.sender, address(this), amtToken);
_approveTokenIfNeeded(rocket, uniRouter);
_approveTokenIfNeeded(token, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtRocket;
uint256 resultAmtToken;
uint256 liquidity;
(resultAmtRocket, resultAmtToken, liquidity) = IUniswapV2Router(uniRouter).addLiquidity(rocket,
token,
amtRocket,
amtToken,
amtRocketMin,
amtTokenMin,
msg.sender,
block.timestamp);
if(amtRocket.sub(resultAmtRocket) > 0) {
IERC20(rocket).transfer(msg.sender, amtRocket.sub(resultAmtRocket));
}
if(amtToken.sub(resultAmtToken) > 0) {
IERC20(token).transfer(msg.sender, amtToken.sub(resultAmtToken));
}
return (resultAmtRocket, resultAmtToken, liquidity);
}
function addLiquidityETHTaxFree(uint256 amtRocket,
uint256 amtRocketMin,
uint256 amtFtmMin)
external
payable
returns (uint256,
uint256,
uint256)
{
require(amtRocket != 0 && msg.value != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(rocket).transferFrom(msg.sender, address(this), amtRocket);
_approveTokenIfNeeded(rocket, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtRocket;
uint256 resultAmtFtm;
uint256 liquidity;
(resultAmtRocket, resultAmtFtm, liquidity) = IUniswapV2Router(uniRouter).addLiquidityETH{value: msg.value}(rocket,
amtRocket,
amtRocketMin,
amtFtmMin,
msg.sender,
block.timestamp);
if(amtRocket.sub(resultAmtRocket) > 0) {
IERC20(rocket).transfer(msg.sender, amtRocket.sub(resultAmtRocket));
}
return (resultAmtRocket, resultAmtFtm, liquidity);
}
function setTaxableRocketOracle(address _rocketOracle) external onlyOperator {
ITaxable(rocket).setRocketOracle(_rocketOracle);
}
function transferTaxOffice(address _newTaxOffice) external onlyOperator {
ITaxable(rocket).setTaxOffice(_newTaxOffice);
}
function taxFreeTransferFrom(address _sender,
address _recipient,
uint256 _amt) external {
require(taxExclusionEnabled[msg.sender], "Address not approved for tax free transfers");
_excludeAddressFromTax(_sender);
IERC20(rocket).transferFrom(_sender, _recipient, _amt);
_includeAddressInTax(_sender);
}
function setTaxExclusionForAddress(address _address, bool _excluded) external onlyOperator {
taxExclusionEnabled[_address] = _excluded;
}
function _approveTokenIfNeeded(address _token, address _router) private {
if (IERC20(_token).allowance(address(this), _router) == 0) {
IERC20(_token).approve(_router, type(uint256).max);
}
}
}
| 312,417 | 13,098 |
56e36d7296375249e81a21f4f330465627afcabc8629f17de6900b5d3def6140
| 12,186 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/contracts_BSC/Staking/StakingRewardsFixedAPY.sol
| 3,008 | 12,081 |
pragma solidity =0.8.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function getOwner() external view returns (address);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface INimbusRouter {
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner, "Ownable: Caller is not the owner");
_;
}
function getOwner() external view returns (address) {
return owner;
}
function transferOwnership(address transferOwner) external onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual external {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
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 SafeBEP20 {
using Address for address;
function safeTransfer(IBEP20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 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(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) - value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IBEP20 token, bytes memory data) private {
require(address(token).isContract(), "SafeBEP20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () {
// 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");
}
}
interface IStakingRewards {
function earned(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function stake(uint256 amount) external;
function stakeFor(uint256 amount, address user) external;
function getReward() external;
function withdraw(uint256 nonce) external;
function withdrawAndGetReward(uint256 nonce) external;
}
interface IBEP20Permit {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract StakingRewardFixedAPY is IStakingRewards, ReentrancyGuard, Ownable {
using SafeBEP20 for IBEP20;
IBEP20 public immutable rewardsToken;
IBEP20 public immutable stakingToken;
INimbusRouter public swapRouter;
uint256 public rewardRate;
uint256 public constant rewardDuration = 365 days;
mapping(address => uint256) public weightedStakeDate;
mapping(address => mapping(uint256 => uint256)) public stakeAmounts;
mapping(address => mapping(uint256 => uint256)) public stakeAmountsRewardEquivalent;
mapping(address => uint256) public stakeNonces;
uint256 private _totalSupply;
uint256 private _totalSupplyRewardEquivalent;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _balancesRewardEquivalent;
event RewardUpdated(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event Rescue(address indexed to, uint amount);
event RescueToken(address indexed to, address indexed token, uint amount);
constructor(address _rewardsToken,
address _stakingToken,
address _swapRouter,
uint _rewardRate) {
require(_rewardsToken != address(0) && _stakingToken != address(0) && _swapRouter != address(0), "StakingRewardFixedAPY: Zero address(es)");
rewardsToken = IBEP20(_rewardsToken);
stakingToken = IBEP20(_stakingToken);
swapRouter = INimbusRouter(_swapRouter);
rewardRate = _rewardRate;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function totalSupplyRewardEquivalent() external view returns (uint256) {
return _totalSupplyRewardEquivalent;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function balanceOfRewardEquivalent(address account) external view returns (uint256) {
return _balancesRewardEquivalent[account];
}
function earned(address account) public view override returns (uint256) {
return _balancesRewardEquivalent[account] * (block.timestamp - weightedStakeDate[account]) * rewardRate / (100 * rewardDuration);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant {
require(amount > 0, "Cannot stake 0");
// permit
IBEP20Permit(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
_stake(amount, msg.sender);
}
function stake(uint256 amount) external override nonReentrant {
require(amount > 0, "StakingRewardFixedAPY: Cannot stake 0");
_stake(amount, msg.sender);
}
function stakeFor(uint256 amount, address user) external override nonReentrant {
require(amount > 0, "StakingRewardFixedAPY: Cannot stake 0");
require(user != address(0), "StakingRewardFixedAPY: Cannot stake for zero address");
_stake(amount, user);
}
function _stake(uint256 amount, address user) private {
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
uint amountRewardEquivalent = getEquivalentAmount(amount);
_totalSupply += amount;
_totalSupplyRewardEquivalent += amountRewardEquivalent;
uint previousAmount = _balances[user];
uint newAmount = previousAmount + amount;
weightedStakeDate[user] = (weightedStakeDate[user] * previousAmount / newAmount) + (block.timestamp * amount / newAmount);
_balances[user] = newAmount;
uint stakeNonce = stakeNonces[user]++;
stakeAmounts[user][stakeNonce] = amount;
stakeAmountsRewardEquivalent[user][stakeNonce] = amountRewardEquivalent;
_balancesRewardEquivalent[user] += amountRewardEquivalent;
emit Staked(user, amount);
}
//A user can withdraw its staking tokens even if there is no rewards tokens on the contract account
function withdraw(uint256 nonce) public override nonReentrant {
require(stakeAmounts[msg.sender][nonce] > 0, "StakingRewardFixedAPY: This stake nonce was withdrawn");
uint amount = stakeAmounts[msg.sender][nonce];
uint amountRewardEquivalent = stakeAmountsRewardEquivalent[msg.sender][nonce];
_totalSupply -= amount;
_totalSupplyRewardEquivalent -= amountRewardEquivalent;
_balances[msg.sender] -= amount;
_balancesRewardEquivalent[msg.sender] -= amountRewardEquivalent;
stakingToken.safeTransfer(msg.sender, amount);
stakeAmounts[msg.sender][nonce] = 0;
stakeAmountsRewardEquivalent[msg.sender][nonce] = 0;
emit Withdrawn(msg.sender, amount);
}
function getReward() public override nonReentrant {
uint256 reward = earned(msg.sender);
if (reward > 0) {
weightedStakeDate[msg.sender] = block.timestamp;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function withdrawAndGetReward(uint256 nonce) external override {
getReward();
withdraw(nonce);
}
function getEquivalentAmount(uint amount) public view returns (uint) {
address[] memory path = new address[](2);
uint equivalent;
if (stakingToken != rewardsToken) {
path[0] = address(stakingToken);
path[1] = address(rewardsToken);
equivalent = swapRouter.getAmountsOut(amount, path)[1];
} else {
equivalent = amount;
}
return equivalent;
}
function updateRewardAmount(uint256 reward) external onlyOwner {
rewardRate = reward;
emit RewardUpdated(reward);
}
function updateSwapRouter(address newSwapRouter) external onlyOwner {
require(newSwapRouter != address(0), "StakingRewardFixedAPY: Address is zero");
swapRouter = INimbusRouter(newSwapRouter);
}
function rescue(address to, address token, uint256 amount) external onlyOwner {
require(to != address(0), "StakingRewardFixedAPY: Cannot rescue to the zero address");
require(amount > 0, "StakingRewardFixedAPY: Cannot rescue 0");
require(token != address(stakingToken), "StakingRewardFixedAPY: Cannot rescue staking token");
//owner can rescue rewardsToken if there is spare unused tokens on staking contract balance
IBEP20(token).safeTransfer(to, amount);
emit RescueToken(to, address(token), amount);
}
function rescue(address payable to, uint256 amount) external onlyOwner {
require(to != address(0), "StakingRewardFixedAPY: Cannot rescue to the zero address");
require(amount > 0, "StakingRewardFixedAPY: Cannot rescue 0");
to.transfer(amount);
emit Rescue(to, amount);
}
}
| 236,124 | 13,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.