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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0fe6b80df82f4aa81630e994166187b30e6fd78fe4e6e4c936cb7c94e3f15613
| 29,484 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/01/017C71d7E10a9AeB26Ed0227E25c54f7165CF3D8_TestToken.sol
| 5,188 | 18,727 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TestToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Test Token';
string private constant _symbol = 'TEST';
uint256 private _taxFee = 100;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x0380f8096629a5Eb76E1010eBbc5e9ef1aF824de, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 321,394 | 800 |
290fa3f8586dbbe0917e89f504dbf763af0bd70d984810c463c1563d712a2fcc
| 10,151 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x03b0be689f36f383568d0a2486834cc6ceddda50.sol
| 3,631 | 10,031 |
pragma solidity ^0.4.18;
// THIS IS A REAL WORLD SIMULATION AS SOCIAL EXPERIMENT
// By sending ETH to the smart contract, you're trusting
// an uncaring mathematical gambling robot to entrust you with Tokens.
// Every Time a Token is purchased, the contract increases the price
// of the next token by a small percentage (about 0.25%).
// Every time a Token is sold, the next Token is valued slightly less (about -0.25%).
// At any time, you can sell your Tokens back to the Smart Contract
// for 90% of the current price, or withdraw just the dividends
// you've accumulated!
// This is a Simulation and kinda a Social Experiment
// ------- DO NOT USE FUNDS YOU CAN'T EFFORT TO LOSE -------
// ------- THIS IS A PURE SIMULATION OF THE CAPABILITIES OF ETHEREUM CONTRACTS -------
// If you want to WITHDRAW accumulated DIVIDENDS
// 1. open MEW/METAMASK
// 2. Put this as data: 0x2e1a7d4d0000000000000000000000000000000000000000000000000000000000000000
// 3. send 50.000+ gas
// If you want to escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150.000+ gas
// That calls the getMeOutOfHere() method
contract EtherPyramid_PowH_Revived {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "EthPyramid";
string constant public symbol = "EPT";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//address owner;
function ethpyramid() public {
//owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 212,512 | 801 |
e4ab623ec682b43f66aae91b7ba5cfdbe0352bc88bf0106e32cc64d08be7bc56
| 16,731 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf28a73603d577041228f543886f512d350c54d25.sol
| 3,215 | 14,032 |
pragma solidity ^0.4.18;
// File: node_modules/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: node_modules/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: node_modules/zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/Marketplace.sol
// TODO: Add require reasons as soon as Solidity 0.4.22 is out (now commented out)
// follow progress at https://github.com/ethereum/solidity/projects/6
contract Marketplace is Ownable {
using SafeMath for uint256;
// product events
event ProductCreated(address indexed owner, bytes32 indexed id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds);
event ProductUpdated(address indexed owner, bytes32 indexed id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds);
event ProductDeleted(address indexed owner, bytes32 indexed id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds);
event ProductRedeployed(address indexed owner, bytes32 indexed id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds);
event ProductOwnershipOffered(address indexed owner, bytes32 indexed id, address indexed to);
event ProductOwnershipChanged(address indexed newOwner, bytes32 indexed id, address indexed oldOwner);
// subscription events
event Subscribed(bytes32 indexed productId, address indexed subscriber, uint endTimestamp);
event NewSubscription(bytes32 indexed productId, address indexed subscriber, uint endTimestamp);
event SubscriptionExtended(bytes32 indexed productId, address indexed subscriber, uint endTimestamp);
event SubscriptionTransferred(bytes32 indexed productId, address indexed from, address indexed to, uint secondsTransferred, uint datacoinTransferred);
// currency events
event ExchangeRatesUpdated(uint timestamp, uint dataInUsd);
enum ProductState {
NotDeployed, // non-existent or deleted
Deployed // created or redeployed
}
enum Currency {
DATA, // data atoms or "wei" (10^-18 DATA)
USD // nanodollars (10^-9 USD)
}
struct Product {
bytes32 id;
string name;
address owner;
address beneficiary; // account where revenue is directed to
uint pricePerSecond;
Currency priceCurrency;
uint minimumSubscriptionSeconds;
ProductState state;
mapping(address => TimeBasedSubscription) subscriptions;
address newOwnerCandidate;
}
struct TimeBasedSubscription {
uint endTimestamp;
}
mapping (bytes32 => Product) products;
function getProduct(bytes32 id) public view returns (string name, address owner, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds, ProductState state) {
return (products[id].name,
products[id].owner,
products[id].beneficiary,
products[id].pricePerSecond,
products[id].priceCurrency,
products[id].minimumSubscriptionSeconds,
products[id].state);
}
function getSubscription(bytes32 productId, address subscriber) public view returns (bool isValid, uint endTimestamp) {
TimeBasedSubscription storage sub;
(isValid, , sub) = _getSubscription(productId, subscriber);
endTimestamp = sub.endTimestamp;
}
function getSubscriptionTo(bytes32 productId) public view returns (bool isValid, uint endTimestamp) {
return getSubscription(productId, msg.sender);
}
ERC20 datacoin;
address public currencyUpdateAgent;
function Marketplace(address datacoinAddress, address currencyUpdateAgentAddress) Ownable() public {
_initialize(datacoinAddress, currencyUpdateAgentAddress);
}
function _initialize(address datacoinAddress, address currencyUpdateAgentAddress) internal {
currencyUpdateAgent = currencyUpdateAgentAddress;
datacoin = ERC20(datacoinAddress);
}
////////////////// Product management /////////////////
// also checks that p exists: p.owner == 0 for non-existent products
modifier onlyProductOwner(bytes32 productId) {
Product storage p = products[productId];
require(p.owner == msg.sender || owner == msg.sender); //, "Only product owner may call this function");
_;
}
function createProduct(bytes32 id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds) public whenNotHalted {
require(id != 0); //, "Product ID can't be empty/null");
require(pricePerSecond > 0); //, "Free streams go through different channel");
Product storage p = products[id];
require(p.id == 0); //, "Product with this ID already exists");
products[id] = Product(id, name, msg.sender, beneficiary, pricePerSecond, currency, minimumSubscriptionSeconds, ProductState.Deployed, 0);
emit ProductCreated(msg.sender, id, name, beneficiary, pricePerSecond, currency, minimumSubscriptionSeconds);
}
function deleteProduct(bytes32 productId) public onlyProductOwner(productId) {
Product storage p = products[productId];
require(p.state == ProductState.Deployed);
p.state = ProductState.NotDeployed;
emit ProductDeleted(p.owner, productId, p.name, p.beneficiary, p.pricePerSecond, p.priceCurrency, p.minimumSubscriptionSeconds);
}
function redeployProduct(bytes32 productId) public onlyProductOwner(productId) {
Product storage p = products[productId];
require(p.state == ProductState.NotDeployed);
p.state = ProductState.Deployed;
emit ProductRedeployed(p.owner, productId, p.name, p.beneficiary, p.pricePerSecond, p.priceCurrency, p.minimumSubscriptionSeconds);
}
function updateProduct(bytes32 productId, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds) public onlyProductOwner(productId) {
require(pricePerSecond > 0); //, "Free streams go through different channel");
Product storage p = products[productId];
p.name = name;
p.beneficiary = beneficiary;
p.pricePerSecond = pricePerSecond;
p.priceCurrency = currency;
p.minimumSubscriptionSeconds = minimumSubscriptionSeconds;
emit ProductUpdated(p.owner, p.id, name, beneficiary, pricePerSecond, currency, minimumSubscriptionSeconds);
}
function offerProductOwnership(bytes32 productId, address newOwnerCandidate) public onlyProductOwner(productId) {
// that productId exists is already checked in onlyProductOwner
products[productId].newOwnerCandidate = newOwnerCandidate;
emit ProductOwnershipOffered(products[productId].owner, productId, newOwnerCandidate);
}
function claimProductOwnership(bytes32 productId) public whenNotHalted {
// also checks that productId exists (newOwnerCandidate is zero for non-existent)
Product storage p = products[productId];
require(msg.sender == p.newOwnerCandidate);
emit ProductOwnershipChanged(msg.sender, productId, p.owner);
p.owner = msg.sender;
p.newOwnerCandidate = 0;
}
/////////////// Subscription management ///////////////
function buy(bytes32 productId, uint subscriptionSeconds) public whenNotHalted {
Product storage product;
TimeBasedSubscription storage sub;
(, product, sub) = _getSubscription(productId, msg.sender);
require(product.state == ProductState.Deployed); //, "Product has been deleted");
_addSubscription(product, msg.sender, subscriptionSeconds, sub);
uint price = _toDatacoin(product.pricePerSecond.mul(subscriptionSeconds), product.priceCurrency);
require(datacoin.transferFrom(msg.sender, product.beneficiary, price)); //, "Not enough DATAcoin allowance");
}
function hasValidSubscription(bytes32 productId, address subscriber) public constant returns (bool isValid) {
(isValid, ,) = _getSubscription(productId, subscriber);
}
function transferSubscription(bytes32 productId, address newSubscriber) public whenNotHalted {
bool isValid = false;
Product storage product;
TimeBasedSubscription storage sub;
(isValid, product, sub) = _getSubscription(productId, msg.sender);
require(isValid); //, "Only valid subscriptions can be transferred");
uint secondsLeft = sub.endTimestamp.sub(block.timestamp);
uint datacoinLeft = secondsLeft.mul(product.pricePerSecond);
TimeBasedSubscription storage newSub = product.subscriptions[newSubscriber];
_addSubscription(product, newSubscriber, secondsLeft, newSub);
delete product.subscriptions[msg.sender];
emit SubscriptionTransferred(productId, msg.sender, newSubscriber, secondsLeft, datacoinLeft);
}
function _getSubscription(bytes32 productId, address subscriber) internal constant returns (bool subIsValid, Product storage, TimeBasedSubscription storage) {
Product storage p = products[productId];
require(p.id != 0); //, "Product doesn't exist");
TimeBasedSubscription storage s = p.subscriptions[subscriber];
return (s.endTimestamp >= block.timestamp, p, s);
}
function _addSubscription(Product storage p, address subscriber, uint addSeconds, TimeBasedSubscription storage oldSub) internal {
uint endTimestamp;
if (oldSub.endTimestamp > block.timestamp) {
require(addSeconds > 0); //, "Must top up worth at least one second");
endTimestamp = oldSub.endTimestamp.add(addSeconds);
oldSub.endTimestamp = endTimestamp;
emit SubscriptionExtended(p.id, subscriber, endTimestamp);
} else {
require(addSeconds >= p.minimumSubscriptionSeconds); //, "More ether required to meet the minimum subscription period");
endTimestamp = block.timestamp.add(addSeconds);
TimeBasedSubscription memory newSub = TimeBasedSubscription(endTimestamp);
p.subscriptions[subscriber] = newSub;
emit NewSubscription(p.id, subscriber, endTimestamp);
}
emit Subscribed(p.id, subscriber, endTimestamp);
}
// TODO: transfer allowance to another Marketplace contract
// Mechanism basically is that this Marketplace draws from the allowance and credits
// the account on another Marketplace; OR that there is a central credit pool (say, an ERC20 token)
/////////////// Currency management ///////////////
uint public dataPerUsd = 1;
function updateExchangeRates(uint timestamp, uint dataUsd) public {
require(msg.sender == currencyUpdateAgent);
require(dataUsd > 0);
dataPerUsd = dataUsd;
emit ExchangeRatesUpdated(timestamp, dataUsd);
}
function updateExchangeRates(uint dataUsd) public {
require(msg.sender == currencyUpdateAgent);
dataPerUsd = dataUsd;
emit ExchangeRatesUpdated(block.timestamp, dataUsd);
}
function _toDatacoin(uint number, Currency unit) view internal returns (uint datacoinAmount) {
if (unit == Currency.DATA) {
return number;
}
return number.mul(dataPerUsd);
}
/////////////// Admin functionality ///////////////
event Halted();
event Resumed();
bool public halted = false;
modifier whenNotHalted() {
require(!halted || owner == msg.sender);
_;
}
function halt() public onlyOwner {
halted = true;
emit Halted();
}
function resume() public onlyOwner {
halted = false;
emit Resumed();
}
function reInitialize(address datacoinAddress, address currencyUpdateAgentAddress) public onlyOwner {
_initialize(datacoinAddress, currencyUpdateAgentAddress);
}
}
| 221,835 | 802 |
7e6f4f175d55bf14c5d4076a3babcb12e8d56f67955f6634165550184ea5ac5e
| 28,900 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0xb7918f5808257e4b7e5e303c33f7bb0364b620aa_affectedByMiners.sol
| 4,262 | 16,488 |
pragma solidity ^0.5.16;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (block.timestamp > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
bool private _notEntered;
constructor () internal {
// Storing an initial non-zero value makes deployment a bit more
// expensive, but in exchange the refund on every call to nonReentrant
// will be lower in amount. Since refunds are capped to a percetange of
// the total transaction's gas, it is best to keep them low in cases
// like this one, to increase the likelihood of the full refund coming
// into effect.
_notEntered = true;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_notEntered, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_notEntered = false;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_notEntered = true;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Inheritance
// https://docs.synthetix.io/contracts/RewardsDistributionRecipient
contract RewardsDistributionRecipient is Ownable {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
rewardsDistribution = _rewardsDistribution;
}
}
// Inheritance
// https://docs.synthetix.io/contracts/Pausable
contract Pausable is Ownable {
uint public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner() != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused, "This action cannot be performed while the contract is paused");
_;
}
}
// Inheritance
contract UniLpRewards is RewardsDistributionRecipient, ReentrancyGuard, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration = 30 days;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _rewardsToken,
address _stakingToken) public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = msg.sender;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (block.number == 0) { //injected CONTRACT AFFECTED BY MINERS
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function stake(uint256 amount) external nonReentrant notPaused updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
if (block.number >= periodFinish) { //injected CONTRACT AFFECTED BY MINERS
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
require(tokenAddress != address(stakingToken) && tokenAddress != address(rewardsToken),
"Cannot withdraw the staking or rewards tokens");
IERC20(tokenAddress).safeTransfer(owner(), tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
require(block.timestamp > periodFinish,
"Previous rewards period must be complete before changing the duration for the new period");
rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(rewardsDuration);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (block.coinbase != address(0)) { //injected CONTRACT AFFECTED BY MINERS
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardsDurationUpdated(uint256 newDuration);
event Recovered(address token, uint256 amount);
}
| 281,145 | 803 |
3cdb260b35a60bacdcb05a709ce6470afd8644a223a55ac748cfec27fa0fb504
| 23,849 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THkRkBnurba9fKB8C26QGtzgouin1jqB2S_Defi.sol
| 6,982 | 23,071 |
//SourceUnit: DefiProd.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns(uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
require(b != 0, errorMessage);
return a % b;
}
function take(uint256 a, uint256 percents) internal pure returns(uint256) {
return div(mul(a, percents), 100);
}
}
contract Utils {
function min(uint256 a, uint256 b) internal pure returns(uint256) {
if (a < b) return a;
return b;
}
function max(uint256 a, uint256 b) internal pure returns(uint256) {
if (a > b) return a;
return b;
}
function inRange(uint256 from, uint256 to, uint256 value) internal pure returns(bool) {
return from <= value && value <= to;
}
}
contract AccountChangable {
address supervisor;
address EMPTY_ADDRESS = address(0);
mapping(address => address) oldToNew;
mapping(address => address) newToOld;
mapping(address => address) requests;
constructor() public { supervisor = msg.sender; }
event ChangeAddressRequest(address oldAddress, address newAddress);
event ApproveChangeAddressRequest(address oldAddress, address newAddress);
function getOriginalAddress(address someAddress) public view returns(address) {
if (newToOld[someAddress] != EMPTY_ADDRESS) return newToOld[someAddress];
return someAddress;
}
function isReplaced(address oldAddress) internal view returns(bool) {
return oldToNew[oldAddress] != EMPTY_ADDRESS;
}
function isNewAddress(address newAddress) public view returns(bool) {
return newToOld[newAddress] != EMPTY_ADDRESS;
}
function getCurrentAddress(address someAddress) internal view returns(address) {
if (oldToNew[someAddress] != EMPTY_ADDRESS) return oldToNew[someAddress];
return someAddress;
}
function requestUpdateAddress(address newAddress) public {
requests[msg.sender] = newAddress;
emit ChangeAddressRequest(msg.sender, newAddress);
}
function accept(address oldAddress, address newAddress) public {
require(msg.sender == supervisor, 'ONLY SUPERVISOR');
require(newAddress != EMPTY_ADDRESS, 'NEW ADDRESS MUST NOT BE EMPTY');
require(requests[oldAddress] == newAddress, 'INCORRECT NEW ADDRESS');
requests[oldAddress] = EMPTY_ADDRESS;
oldToNew[oldAddress] = newAddress;
newToOld[newAddress] = oldAddress;
emit ApproveChangeAddressRequest(oldAddress, newAddress);
}
}
contract IToken {
function transferFrom(address from, address to, uint value) public;
function transfer(address to, uint value) public;
}
contract Defi is AccountChangable, Utils {
using SafeMath for uint256;
address USDT_CONTRACT_ADDRESS;
address SHF_CONTRACT_ADDRESS;
string public version = '1.0.0';
uint256 ONE_DAY = 86400;
address rootAdmin;
address builderFund;
address lotteryFund;
uint256 ROOT_LEVEL = 1;
mapping(address => Investor) investors;
event CreateInvestor(address investorAddress, address presenterAddress, uint256 level);
event BalanceChange(address investorAddress, uint256 amount, address tokenAddress, uint256 reason);
struct Investor {
address investorAddress;
address presenterAddress;
uint256 level;
uint256 usdtBalance;
uint256 shfBalance;
uint256 rank; // default = 0; silver = 1; gold = 2; diamond = 3
uint256 investedF1;
uint256 silverF1;
uint256 goldF1;
uint256 lastPackageCreatedAt;
}
uint256 BALANCE_CHANGE_REASON_DEPOSIT = 0;
uint256 BALANCE_CHANGE_REASON_WITHDRAW = 1;
uint256 BALANCE_CHANGE_REASON_BUY_PACKAGE = 2;
uint256 BALANCE_CHANGE_REASON_SYSTEM_COMMISSION = 3;
uint256 BALANCE_CHANGE_REASON_DIRECT_COMMISSION = 4;
uint256 BALANCE_CHANGE_REASON_SEND_TRANSFER = 5;
uint256 BALANCE_CHANGE_REASON_RECEIVE_TRANSFER = 6;
uint256 BALANCE_CHANGE_REASON_RECEIVE_WITHDRAW_FEE = 7;
uint256 BALANCE_CHANGE_REASON_CLAIM = 8;
uint256 BALANCE_CHANGE_REASON_CLAIM_COMMISSION = 9;
uint256 BALANCE_CHANGE_REASON_BUILDER_FUND = 10;
uint256 BALANCE_CHANGE_REASON_LOTTERY_FUND = 11;
uint256 BALANCE_CHANGE_REASON_SWAP_FROM = 12;
uint256 BALANCE_CHANGE_REASON_SWAP_TO = 13;
uint256 BALANCE_CHANGE_REASON_SWAP_FEE = 14;
uint256 BALANCE_CHANGE_REASON_WITHDRAW_FEE = 15;
uint256 BALANCE_CHANGE_REASON_DEVELOPMENT_FUND = 16;
uint256 public startAt;
constructor(address rootAddress, address usdtAddress, address shfAddress) public {
USDT_CONTRACT_ADDRESS = usdtAddress;
SHF_CONTRACT_ADDRESS = shfAddress;
rootAdmin = rootAddress;
builderFund = rootAddress;
lotteryFund = rootAddress;
uint256 FIRST_LEVEL = 1;
createInvestor(rootAddress, EMPTY_ADDRESS, FIRST_LEVEL);
startAt = now;
}
modifier mustNotBeReplacedAddress() {
require(!isReplaced(msg.sender), 'REPLACED ADDRESS');
_;
}
modifier mustBeRootAdmin() {
require(!isReplaced(msg.sender), 'REPLACED ADDRESS');
require(getOriginalAddress(msg.sender) == rootAdmin, 'ONLY ADMIN');
_;
}
uint256 public rate = 150000;
event SetRate(uint256 rate);
function setRate(uint256 newRate) public mustBeRootAdmin {
rate = newRate;
emit SetRate(rate);
}
function convertUsdtToShf(uint256 usdtAmount) public view returns (uint256) {
return (10 ** 12) * 1000000 * usdtAmount / rate;
}
function convertShfToUsdt(uint256 shfAmount) public view returns (uint256) {
return shfAmount * rate / (10 ** 12) / 1000000;
}
function createInvestor(address investorAddress, address presenterAddress, uint256 level) internal {
investors[investorAddress] = Investor({
investorAddress: investorAddress,
presenterAddress: presenterAddress,
level: level,
usdtBalance: 0,
shfBalance: 0,
investedF1: 0,
silverF1: 0,
goldF1: 0,
rank: 0,
lastPackageCreatedAt: 0
});
emit CreateInvestor(investorAddress, presenterAddress, level);
}
function hasReadPermissionOnAddress(address targetedAddress) internal view returns(bool) {
if (isReplaced(msg.sender)) return false;
address originalAddress = getOriginalAddress(msg.sender);
bool isRootAdmin = originalAddress == rootAdmin;
bool isMyAccount = originalAddress == targetedAddress;
return isRootAdmin || isMyAccount;
}
function () external payable {}
function getNow() internal view returns(uint256) {
return now;
}
function deposit(uint256 amount, bool isUsdt) public {
address investorAddress = getOriginalAddress(msg.sender);
require(isInvestor(investorAddress), 'REGISTER_FIRST');
if (amount == 0) return;
address tokenAddress = isUsdt ? USDT_CONTRACT_ADDRESS : SHF_CONTRACT_ADDRESS;
IToken(tokenAddress).transferFrom(msg.sender, address(this), amount);
increaseBalance(investorAddress,
amount,
tokenAddress,
BALANCE_CHANGE_REASON_DEPOSIT);
}
function increaseBalance(address investorAddress, uint256 value, address tokenAddress, uint256 reason) internal {
Investor storage investor = investors[investorAddress];
if (tokenAddress == USDT_CONTRACT_ADDRESS) {
investor.usdtBalance = investor.usdtBalance.add(value);
} else {
investor.shfBalance = investor.shfBalance.add(value);
}
emit BalanceChange(investorAddress, value, tokenAddress, reason);
}
function decreaseBalance(address investorAddress, uint256 value, address tokenAddress, uint256 reason, string memory errorMessage) internal {
Investor storage investor = investors[investorAddress];
if (tokenAddress == USDT_CONTRACT_ADDRESS) {
investor.usdtBalance = investor.usdtBalance.sub(value, errorMessage);
} else {
investor.shfBalance = investor.shfBalance.sub(value, errorMessage);
}
emit BalanceChange(investorAddress, value, tokenAddress, reason);
}
function register(address presenter, uint256 usdtAmount, uint256 shfAmount) public {
address investorAddress = getOriginalAddress(msg.sender);
address presenterAddress = getOriginalAddress(presenter);
require(!isInvestor(investorAddress), 'ADDRESS_IS_USED');
createInvestor(investorAddress,
presenterAddress,
investors[presenterAddress].level.add(1));
bool isUsdt = true;
if (usdtAmount != 0) deposit(usdtAmount, isUsdt);
if (shfAmount != 0) deposit(shfAmount, !isUsdt);
}
uint256 public PACKAGE_PRICE_IN_USDT = 135000000;
uint256 public DIRECT_COMMISSION_RATE = 8;
function buyPackage(uint256 usdtAmount) public mustNotBeReplacedAddress {
address originalAddress = getOriginalAddress(msg.sender);
Investor storage investor = investors[originalAddress];
bool hasActivePackage = (investor.lastPackageCreatedAt != 0 &&
getNow() - investor.lastPackageCreatedAt <= 30 * ONE_DAY);
require(!hasActivePackage, 'HAS_ACTIVE_PACKAGE');
require(usdtAmount <= PACKAGE_PRICE_IN_USDT, 'TOO_MUCH_USDT');
if (usdtAmount != 0) decreaseBalance(originalAddress,
usdtAmount,
USDT_CONTRACT_ADDRESS,
BALANCE_CHANGE_REASON_BUY_PACKAGE,
'NOT_ENOUGH_USDT');
uint256 shfAmount = convertUsdtToShf(PACKAGE_PRICE_IN_USDT - usdtAmount);
if (shfAmount != 0) decreaseBalance(originalAddress,
shfAmount,
SHF_CONTRACT_ADDRESS,
BALANCE_CHANGE_REASON_BUY_PACKAGE,
'NOT_ENOUGH_SHF');
payToFunds();
payCommissionForPresenters(investor.presenterAddress,
convertUsdtToShf(PACKAGE_PRICE_IN_USDT.take(DIRECT_COMMISSION_RATE)),
BALANCE_CHANGE_REASON_DIRECT_COMMISSION);
payCommissionForPresenters(investors[investor.presenterAddress].presenterAddress,
convertUsdtToShf(PACKAGE_PRICE_IN_USDT.take(DIRECT_COMMISSION_RATE)),
BALANCE_CHANGE_REASON_DIRECT_COMMISSION);
paySystemCommission(originalAddress);
if (investor.lastPackageCreatedAt == 0) updatePresenterRanks(originalAddress);
createPackage(originalAddress);
}
function updatePresenterRanks(address investorAddress) internal {
address presenterAddress = investors[investorAddress].presenterAddress;
investors[presenterAddress].investedF1++;
address next = presenterAddress;
for (uint256 step = 1; step <= 3; step++) {
Investor storage investor = investors[next];
uint256 newRank = getNewRank(investor);
if (newRank == investor.rank) return;
investor.rank = newRank;
next = investor.presenterAddress;
if (newRank == 1) investors[next].silverF1++;
if (newRank == 2) investors[next].goldF1++;
}
}
function getNewRank(Investor memory investor) internal pure returns(uint256) {
if (investor.goldF1 >= 3) return 3;
if (investor.silverF1 >= 3) return 2;
if (investor.investedF1 >= 20) return 1;
return 0;
}
uint256[] rewards = [0, 450000, 900000, 1350000];
function paySystemCommission(address investorAddress) internal {
uint256 NUMBER_OF_LEVEL = 15;
uint256 investorLevel = investors[investorAddress].level;
uint256 steps = investorLevel <= NUMBER_OF_LEVEL ? investorLevel - 1: NUMBER_OF_LEVEL;
address next = investorAddress;
for (uint256 step = 1; step <= steps; step++) {
address presenterAddress = investors[next].presenterAddress;
Investor memory presenter = investors[presenterAddress];
next = presenterAddress;
if (presenter.rank == 0) continue;
payCommissionForPresenters(presenterAddress,
convertUsdtToShf(rewards[presenter.rank]),
BALANCE_CHANGE_REASON_SYSTEM_COMMISSION);
}
}
function setBuilderFundAdmin(address builderFundAddress) public mustBeRootAdmin {
require(isInvestor(builderFundAddress), 'BUILDER_ADMIN_MUST_BE_INVESTOR');
builderFund = builderFundAddress;
}
function setLotteryFundFundAdmin(address lotteryFundAddress) public mustBeRootAdmin {
require(isInvestor(lotteryFundAddress), 'LOTTERY_ADMIN_MUST_BE_INVESTOR');
lotteryFund = lotteryFundAddress;
}
uint256 public BUILDER_FUND_INTEREST = 7;
uint256 public DEVELOPMENT_FUND_INTEREST = 3;
uint256 public LOTTERY_FUND_INTEREST = 10;
function payToFunds() internal {
increaseBalance(builderFund,
convertUsdtToShf(PACKAGE_PRICE_IN_USDT.take(BUILDER_FUND_INTEREST)),
SHF_CONTRACT_ADDRESS,
BALANCE_CHANGE_REASON_BUILDER_FUND);
increaseBalance(rootAdmin,
convertUsdtToShf(PACKAGE_PRICE_IN_USDT.take(DEVELOPMENT_FUND_INTEREST)),
SHF_CONTRACT_ADDRESS,
BALANCE_CHANGE_REASON_DEVELOPMENT_FUND);
increaseBalance(lotteryFund,
convertUsdtToShf(PACKAGE_PRICE_IN_USDT.take(LOTTERY_FUND_INTEREST)),
SHF_CONTRACT_ADDRESS,
BALANCE_CHANGE_REASON_LOTTERY_FUND);
}
function payCommissionForPresenters(address presenterAddress, uint256 value, uint256 reason) internal {
Investor storage investor = investors[getOriginalAddress(presenterAddress)];
bool isActive = investor.lastPackageCreatedAt + 30 * ONE_DAY > getNow();
increaseBalance(isActive ? presenterAddress: rootAdmin,
value,
SHF_CONTRACT_ADDRESS,
reason);
}
uint256 public DAILY_PAYOUT_INTEREST = 5;
mapping (address => uint256) public lastClaimedAt;
uint256 IN_SKIP_DAY = 1;
uint256 STILL_IN_FIRST_DAY = 2;
uint256 ALREADY_CALIMED_TODAY = 3;
uint256 NO_PACKAGE = 4;
uint256 EXPIRED_PACKAGE = 5;
uint256 CAN_CLAIM = 0;
function canClaim() public view returns(uint256) {
address originalAddress = getOriginalAddress(msg.sender);
uint256 lastPackageCreatedAt = investors[originalAddress].lastPackageCreatedAt;
if (lastPackageCreatedAt == 0) return NO_PACKAGE;
if (lastPackageCreatedAt + ONE_DAY > getNow()) return STILL_IN_FIRST_DAY;
uint256 dayPassed = (getNow() - lastPackageCreatedAt) / ONE_DAY;
if (dayPassed >= 31) return EXPIRED_PACKAGE;
if (dayPassed % 2 == 0 || dayPassed == 29) return IN_SKIP_DAY;
bool claimedToday = lastClaimedAt[originalAddress] != 0 && dayPassed == (lastClaimedAt[originalAddress] - lastPackageCreatedAt) / ONE_DAY;
if (claimedToday) return ALREADY_CALIMED_TODAY;
return CAN_CLAIM;
}
function ensureCanClaim() internal view {
uint256 claimCase = canClaim();
require(claimCase != IN_SKIP_DAY, 'IN_SKIP_DAY');
require(claimCase != STILL_IN_FIRST_DAY, 'STILL_IN_FIRST_DAY');
require(claimCase != ALREADY_CALIMED_TODAY, 'ALREADY_CALIMED_TODAY');
require(claimCase != NO_PACKAGE, 'NO_PACKAGE');
require(claimCase != EXPIRED_PACKAGE, 'EXPIRED_PACKAGE');
}
uint256 public DIRECT_CLAIM_COMMISSION_RATE = 2;
uint256 public IN_DIRECT_CLAIM_COMMISSION_RATE = 1;
function claim() public mustNotBeReplacedAddress {
ensureCanClaim();
address originalAddress = getOriginalAddress(msg.sender);
Investor storage investor = investors[originalAddress];
uint256 shfAmount = convertUsdtToShf(PACKAGE_PRICE_IN_USDT.take(DAILY_PAYOUT_INTEREST * 2));
increaseBalance(originalAddress,
shfAmount,
SHF_CONTRACT_ADDRESS,
BALANCE_CHANGE_REASON_CLAIM);
lastClaimedAt[originalAddress] = getNow();
payCommissionForPresenters(investor.presenterAddress,
shfAmount.take(DIRECT_CLAIM_COMMISSION_RATE),
BALANCE_CHANGE_REASON_CLAIM_COMMISSION);
payCommissionForPresenters(investors[investor.presenterAddress].presenterAddress,
shfAmount.take(IN_DIRECT_CLAIM_COMMISSION_RATE),
BALANCE_CHANGE_REASON_CLAIM_COMMISSION);
}
function swap(uint256 value, bool fromUsdt) public mustNotBeReplacedAddress {
address investorAddress = getOriginalAddress(msg.sender);
address fromToken = fromUsdt ? USDT_CONTRACT_ADDRESS : SHF_CONTRACT_ADDRESS;
address toToken = fromUsdt ? SHF_CONTRACT_ADDRESS : USDT_CONTRACT_ADDRESS;
uint256 destValue = fromUsdt ? convertUsdtToShf(value) : convertShfToUsdt(value);
decreaseBalance(investorAddress,
value,
fromToken,
BALANCE_CHANGE_REASON_SWAP_FROM,
fromUsdt ? 'NOT_ENOUGH_USDT' : 'NOT_ENOUGH_SHF');
increaseBalance(investorAddress,
destValue.take(99),
toToken,
BALANCE_CHANGE_REASON_SWAP_TO);
increaseBalance(rootAdmin,
value.take(1),
fromToken,
BALANCE_CHANGE_REASON_SWAP_FEE);
}
function getPeriodIndex() internal view returns(uint256) {
return (getNow() - startAt) / (10 * ONE_DAY);
}
mapping(address => mapping(address => mapping(uint256 => uint256))) withdrewThisPeriod;
function increaseUsedWithdrawQuota(address investorAddress, address tokenAddress, uint256 value) internal {
withdrewThisPeriod[investorAddress][tokenAddress][getPeriodIndex()] += value;
}
function getCurrentUsedQuota(address investorAddress, address tokenAddress) internal view returns(uint256) {
return withdrewThisPeriod[investorAddress][tokenAddress][getPeriodIndex()];
}
function withdraw(uint256 value, bool isUsdt) public mustNotBeReplacedAddress {
address investorAddress = getOriginalAddress(msg.sender);
if (investorAddress != rootAdmin) require(value <= getRemainWithdrawQuota(isUsdt), 'OVER_QUOTA');
address tokenAddress = isUsdt ? USDT_CONTRACT_ADDRESS : SHF_CONTRACT_ADDRESS;
decreaseBalance(investorAddress,
value,
tokenAddress,
BALANCE_CHANGE_REASON_WITHDRAW,
isUsdt ? 'NOT_ENOUGH_USDT' : 'NOT_ENOUGH_SHF');
increaseBalance(builderFund,
value.take(BUILDER_FUND_INTEREST),
tokenAddress,
BALANCE_CHANGE_REASON_WITHDRAW_FEE);
increaseBalance(rootAdmin,
value.take(DEVELOPMENT_FUND_INTEREST),
tokenAddress,
BALANCE_CHANGE_REASON_WITHDRAW_FEE);
IToken(tokenAddress).transfer(investorAddress, value.take(100 - (BUILDER_FUND_INTEREST + DEVELOPMENT_FUND_INTEREST)));
increaseUsedWithdrawQuota(investorAddress, tokenAddress, value);
}
uint256 USDT_FACTOR = 10 ** 6;
uint256 SHF_FACTOR = 10 ** 18;
uint256[] withdrawQuotaUsdt = [0, 100 * USDT_FACTOR, 150 * USDT_FACTOR, 400 * USDT_FACTOR];
uint256[] withdrawQuotaShf = [0, 600 * SHF_FACTOR, 900 * SHF_FACTOR, 2700 * SHF_FACTOR];
function getRemainWithdrawQuota(bool isUsdt) public view returns(uint256) {
address investorAddress = getOriginalAddress(msg.sender);
uint256 rank = investors[getOriginalAddress(msg.sender)].rank;
if (isUsdt) return withdrawQuotaUsdt[rank] - getCurrentUsedQuota(investorAddress, USDT_CONTRACT_ADDRESS);
return withdrawQuotaShf[rank] - getCurrentUsedQuota(investorAddress, SHF_CONTRACT_ADDRESS);
}
function transfer(address receiverAddress, uint256 value, bool isUsdt) public mustNotBeReplacedAddress {
address senderAddress = getOriginalAddress(msg.sender);
require(receiverAddress != senderAddress, 'SELF_TRANSFER');
require(isInvestor(receiverAddress), 'INVALID_RECEIVER');
require(isOnSameBranch(receiverAddress), 'ONLY_SAME_BRANCH');
if (!isUsdt) {
uint256 MIN_SHF_TRANSFER_VALUE = 300 * 10 ** 18;
require(value >= MIN_SHF_TRANSFER_VALUE, 'MIN_300_SHF');
require(value % MIN_SHF_TRANSFER_VALUE == 0, 'MULTIPLES_OF_300_SHF');
}
decreaseBalance(senderAddress,
value,
isUsdt ? USDT_CONTRACT_ADDRESS : SHF_CONTRACT_ADDRESS,
BALANCE_CHANGE_REASON_SEND_TRANSFER,
isUsdt ? 'NOT_ENOUGH_USDT' : 'NOT_ENOUGH_SHF');
increaseBalance(receiverAddress,
value,
isUsdt ? USDT_CONTRACT_ADDRESS : SHF_CONTRACT_ADDRESS,
BALANCE_CHANGE_REASON_RECEIVE_TRANSFER);
}
function isOnSameBranch(address receiverAddress) public view returns(bool) {
Investor memory sender = investors[getOriginalAddress(msg.sender)];
Investor memory receiver = investors[receiverAddress];
bool goingUp = sender.level > receiver.level;
Investor memory from = goingUp ? sender : receiver;
Investor memory to = goingUp ? receiver : sender;
uint256 step = from.level - to.level;
address endAddress = from.investorAddress;
for (uint256 index = 0; index < step; index++) endAddress = investors[endAddress].presenterAddress;
return endAddress == to.investorAddress;
}
event CreatePackage(address investorAddress, uint256 packageId);
uint256 packageCount = 0;
function createPackage(address originalAddress) internal {
emit CreatePackage(originalAddress, ++packageCount);
investors[originalAddress].lastPackageCreatedAt = getNow();
}
function isInvestor(address investorAddress) public view returns(bool) {
return investors[getOriginalAddress(investorAddress)].level != 0;
}
function getInvestor(address investorAddr) public view returns(uint256 usdtBalance, uint256 shfBalance, uint256 rank, uint256 investedF1, uint256 silverF1, uint256 goldF1, uint256 lastPackageCreatedAt) {
address originalAddress = getOriginalAddress(investorAddr);
require(hasReadPermissionOnAddress(originalAddress), 'PERMISSION DENIED');
Investor memory investor = investors[originalAddress];
return (investor.usdtBalance,
investor.shfBalance,
investor.rank,
investor.investedF1,
investor.silverF1,
investor.goldF1,
investor.lastPackageCreatedAt);
}
function getInvestors(address[] memory listAddresses) public mustBeRootAdmin view returns (uint256[] memory usdtBalances, uint256[] memory shfBalances, uint256[] memory ranks, uint256[] memory investedF1s, uint256[] memory silverF1s, uint256[] memory goldF1s, uint256[] memory lastPackageCreatedAts) {
uint256 length = listAddresses.length;
usdtBalances = new uint256[](length);
shfBalances = new uint256[](length);
ranks = new uint256[](length);
investedF1s = new uint256[](length);
silverF1s = new uint256[](length);
goldF1s = new uint256[](length);
lastPackageCreatedAts = new uint256[](length);
for (uint256 index = 0; index < length; index++) {
Investor memory investor = investors[listAddresses[index]];
usdtBalances[index] = investor.usdtBalance;
shfBalances[index] = investor.shfBalance;
ranks[index] = investor.rank;
investedF1s[index] = investor.investedF1;
silverF1s[index] = investor.silverF1;
goldF1s[index] = investor.goldF1;
lastPackageCreatedAts[index] = investor.lastPackageCreatedAt;
}
return (usdtBalances, shfBalances, ranks, investedF1s, silverF1s, goldF1s, lastPackageCreatedAts);
}
}
| 294,076 | 804 |
e896f28c4208c3e3ada4f7e73a7739d8417a4fc94471a8f8650ed3544a37ef88
| 14,584 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1bc270c8765247fe5669f2ab4d8563380a0ec752.sol
| 2,761 | 11,195 |
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 HGBPToken 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 HGBPToken(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 issuedi
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);
}
| 215,646 | 805 |
041b3237793770af9838ddda2ab36b19a83850b378a19e729d9bd71c5fb4b714
| 25,409 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDSyumaoM7dVLSkcMF92hNykVJLasV7RR8_TronBTCApp.sol
| 6,773 | 21,482 |
//SourceUnit: TronBTC.sol
pragma solidity ^0.5.8;
contract TronBTCApp {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public contractOwner;
IERC20 public PlatformTokenApp;
uint256 constant public TOKENS_PER_ROUND = 1000000;
uint256 constant public BURN_RATE_SECONDS_DEVIDER = 86400;
uint256 private timeDevider = 1000000000000;
uint256 constant public TOKENS_DECIMAL = 6;
address payable public platformAddress;
uint256 public globalNoOfInvestors;
uint256 public globalInvested;
uint256 public globalTokensGiven;
uint256 public globalTokensBurned;
uint256 public presentLevelNumber;
uint256 public donated;
///////////new memebers profitability (nmp) variables///
uint256 private nmpLastWonCheckPoint;
uint256 private nmpIdDeposit;
uint256 public NMP_RANDOM_BASE;
uint256 public NMP_RANDOM_DEVIDER;
uint256 public NMP_MIN_DEPOSIT;
uint256 public NMP_MIN_DONATED;
uint256 public NMP_DEPOSIT_PERCENT;
uint256 public NMP_DONATED_PERCENT;
///////////new memebers profitability//////////////////
struct Investor {
uint256 trxDeposit;
uint256 depositTime;
uint256 profitGained;
uint256 referralBonus;
uint256 howmuchPaid;
address upline;
uint256 invested;
uint256 reinvested;
uint256 tokensIssued;
uint256 tokensBurned;
uint256 lastWithdrawTime;
uint256 basicUser;
}
mapping(address => Investor) private investors;
event EvtNewbie(address indexed investor, uint256 amount,address indexed _referrer);
event EvtNewDeposit(address indexed investor, uint256 amount);
event EvtWithdrawn(address indexed investor, uint256 amount);
event EvtReinvest(address indexed investor, uint256 amount);
event EvtReferralBonus(address indexed referrer, address indexed investor, uint256 indexed level, uint256 amount);
event EvtTokensGiven(address indexed investor, uint256 stake_amount, uint256 amount, uint256 presentLevelNumber, uint256 basicUser);
event EvtTokensSwapBurn(address indexed investor,uint256 trxToBurn, uint256 amount, uint256 npmGift, uint256 winCheckPoint,uint256 nmpLastWonCheckPoint);
event EvtTokensBurn(address indexed investor,uint256 amount, uint256 basicUser);
address payable internal PAIR_ADDRESS;
IJustswapExchange justswap;
constructor(address payable exchangeAddress, IERC20 myTokenAddress, address payable platformAddr) public {
contractOwner = msg.sender;
presentLevelNumber=1;
NMP_RANDOM_BASE = 10;
NMP_RANDOM_DEVIDER = 10;
NMP_MIN_DEPOSIT = 100;
NMP_MIN_DONATED=100;
NMP_DEPOSIT_PERCENT=25;
NMP_DONATED_PERCENT=25;
PAIR_ADDRESS = exchangeAddress;
justswap = IJustswapExchange(PAIR_ADDRESS);
IERC20(myTokenAddress).approve(exchangeAddress, 1000000000000000000000);
PlatformTokenApp = myTokenAddress;
platformAddress = platformAddr;
}
function () external payable {
}
function setLevel() private {
uint256 t = globalTokensGiven.div(10**TOKENS_DECIMAL).div(TOKENS_PER_ROUND);
presentLevelNumber = t+1;
}
function setContractOwner(address _contractOwner) public {
require(msg.sender == contractOwner, "!co");
contractOwner = _contractOwner;
}
function setNmpRandomDevider(uint256 _NMP_RANDOM_BASE, uint256 _NMP_RANDOM_DEVIDER, uint256 _NMP_MIN_DEPOSIT, uint256 _NMP_MIN_DONATED, uint256 _NMP_DEPOSIT_PERCENT, uint256 _NMP_DONATED_PERCENT) public {
require(msg.sender == platformAddress, "!pa");
NMP_RANDOM_BASE = _NMP_RANDOM_BASE;
NMP_RANDOM_DEVIDER = _NMP_RANDOM_DEVIDER;
NMP_MIN_DEPOSIT = _NMP_MIN_DEPOSIT;
NMP_MIN_DONATED=_NMP_MIN_DONATED;
NMP_DEPOSIT_PERCENT=_NMP_DEPOSIT_PERCENT;
NMP_DONATED_PERCENT=_NMP_DONATED_PERCENT;
}
function register(address _addr, address _upline) private{
Investor storage investor = investors[_addr];
investor.upline = _upline;
address _upline1 = _upline;
}
function issueTokens(address _depositor, uint256 _amount) internal {
Investor storage investor = investors[_depositor];
uint256 levelDevider = presentLevelNumber.mul(5);
levelDevider = levelDevider.add(5);
uint256 noOfTokensToGive = _amount.div(levelDevider);
if(investor.basicUser==1) {
PlatformTokenApp.mint(_depositor, noOfTokensToGive);
uint256 toBurnForBasicUser = noOfTokensToGive.mul(9).div(10);
PlatformTokenApp.burn(_depositor, toBurnForBasicUser);
investor.tokensBurned = investor.tokensBurned.add(toBurnForBasicUser);
emit EvtTokensBurn(msg.sender,toBurnForBasicUser, investor.basicUser);
} else {
PlatformTokenApp.mint(_depositor, noOfTokensToGive);
}
PlatformTokenApp.mint(platformAddress, noOfTokensToGive.div(10));
investor.tokensIssued = investor.tokensIssued + noOfTokensToGive;
globalTokensGiven = globalTokensGiven + noOfTokensToGive;
setLevel();
emit EvtTokensGiven(_depositor, _amount, noOfTokensToGive, presentLevelNumber, investor.basicUser);
}
function burnTokensAmount(uint256 _amount) public {
Investor storage investor = investors[msg.sender];
require(investor.basicUser==2, "!aa");
PlatformTokenApp.burn(msg.sender, _amount);
investor.tokensBurned = investor.tokensBurned.add(_amount);
emit EvtTokensBurn(msg.sender,_amount, investor.basicUser);
}
function deposit(address _upline, uint256 _basicUser) public payable {
require(msg.value >= 100 trx, "ma");
Investor storage investor = investors[msg.sender];
uint256 depositAmount = msg.value;
globalInvested = globalInvested.add(depositAmount);
updateProfits(msg.sender);
if (investor.depositTime == 0) {
investor.depositTime = now;
investor.basicUser = _basicUser;
globalNoOfInvestors = globalNoOfInvestors.add(1);
if(_upline != address(0) && investors[_upline].trxDeposit > 0){
emit EvtNewbie(msg.sender,depositAmount, _upline);
register(msg.sender, _upline);
}
else{
emit EvtNewbie(msg.sender,depositAmount,contractOwner);
register(msg.sender, contractOwner);
}
//////////////NPM code/////////////////////
if(donated > NMP_MIN_DONATED && depositAmount > NMP_MIN_DEPOSIT && nmpIdDeposit < depositAmount) {
nmpIdDeposit=depositAmount;
uint256 minuteRandomizer = block.timestamp.mod(NMP_RANDOM_DEVIDER).add(NMP_RANDOM_BASE);
uint256 winCheckPoint = block.timestamp.sub(minuteRandomizer.mul(60));
if(winCheckPoint > nmpLastWonCheckPoint) {
//transfer gift to new depositor and swap the rest with token and burn
uint256 npmGift = 0;
npmGift = depositAmount.mul(NMP_DEPOSIT_PERCENT).div(100);
if (npmGift > donated.mul(NMP_DONATED_PERCENT).div(100)) {
npmGift = donated.mul(NMP_DONATED_PERCENT).div(100);
}
donated = donated.sub(npmGift);
msg.sender.transfer(npmGift);
tokenBurn(npmGift, winCheckPoint, nmpLastWonCheckPoint);
nmpLastWonCheckPoint=block.timestamp;
nmpIdDeposit=0;
}
}
//////////////NPM code/////////////////////
}
issueTokens(msg.sender, depositAmount);
investor.lastWithdrawTime = now;
investor.trxDeposit = investor.trxDeposit.add(depositAmount);
investor.invested += depositAmount;
payUplines(msg.value, investor.upline);
emit EvtNewDeposit(msg.sender, depositAmount);
platformAddress.transfer(depositAmount.div(10));
}
function tokenBurn(uint256 _npmGift, uint256 _winCheckPoint, uint256 _nmpLastWonCheckPoint) private {
uint256 tokenToBurn;
tokenToBurn = justswap.trxToTokenTransferInput.value(donated)(1, now + 100000000, address(this));
globalTokensBurned = globalTokensBurned + tokenToBurn;
PlatformTokenApp.burn(address(this), tokenToBurn);
emit EvtTokensSwapBurn(msg.sender,donated, tokenToBurn, _npmGift, _winCheckPoint, _nmpLastWonCheckPoint);
donated = 0;
}
function withdraw(uint256 wPercent) public {
require(wPercent>=1 && wPercent <=100, "pr");
updateProfits(msg.sender);
require(investors[msg.sender].profitGained > 0);
uint256 transferAmount;
transferAmount = investors[msg.sender].profitGained.mul(wPercent).div(100);
transferProfitGained(msg.sender, transferAmount);
}
function reinvest() public {
updateProfits(msg.sender);
Investor storage investor = investors[msg.sender];
uint256 depositAmount = investor.profitGained;
require(address(this).balance >= depositAmount);
investor.profitGained = 0;
investor.trxDeposit = investor.trxDeposit.add(depositAmount/2);
investor.reinvested += depositAmount;
emit EvtReinvest(msg.sender, depositAmount);
payUplines(depositAmount, investor.upline);
platformAddress.transfer(depositAmount.div(10));
issueTokens(msg.sender, depositAmount.div(2).div(10));
investor.lastWithdrawTime = now;
}
function updateProfits(address _addr) internal {
Investor storage investor = investors[_addr];
uint256 grm = getRateMultiplier();
uint256 secPassed = now.sub(investor.depositTime);
if (secPassed > 0 && investor.depositTime > 0) {
uint256 calculateProfit = (investor.trxDeposit.mul(secPassed.mul(grm))).div(timeDevider);
investor.profitGained = investor.profitGained.add(calculateProfit);
if (investor.profitGained >= investor.trxDeposit.mul(3)){
investor.profitGained = investor.trxDeposit.mul(3);
}
investor.depositTime = investor.depositTime.add(secPassed);
}
}
function transferProfitGained(address _receiver, uint256 _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint256 contractBalance = address(this).balance;
if (contractBalance > 0) {
uint256 payout = _amount > contractBalance ? contractBalance : _amount;
Investor storage investor = investors[_receiver];
if(investor.basicUser==2){
uint256 systemBurnRate = calculateSystemBurnRate(_receiver);
uint256 myBurnRate = calculateMyBurnRate(_receiver);
require(myBurnRate >= systemBurnRate, "!br");
}
investor.howmuchPaid = investor.howmuchPaid.add(payout);
investor.profitGained = investor.profitGained.sub(payout);
investor.trxDeposit = investor.trxDeposit.sub(payout/2);
investor.trxDeposit = investor.trxDeposit.add(payout.div(4));
msg.sender.transfer(payout.mul(3).div(4)); // 75% to user
investor.lastWithdrawTime = now;
donated += payout.div(4); // 25% percent
emit EvtWithdrawn(msg.sender, payout);
}
}
}
function calculateSystemBurnRate(address _addr) public view returns (uint256) {
Investor storage investor = investors[_addr];
uint256 daysPassed = 0;
uint256 csbr = 90;
if(investor.lastWithdrawTime>0) {
daysPassed = now.sub(investor.lastWithdrawTime).div(BURN_RATE_SECONDS_DEVIDER);
if (daysPassed > 89) {
csbr = 0;
} else {
csbr = csbr.sub(daysPassed);
}
}
return csbr;
}
function calculateMyBurnRate(address _addr) public view returns (uint256) {
Investor storage investor = investors[_addr];
uint256 cmbr = 0;
if(investor.tokensIssued>0) {
cmbr = cmbr.add(investor.tokensBurned.mul(100).div(investor.tokensIssued));
}
return cmbr;
}
function getProfit(address _addr) public view returns (uint256) {
Investor storage investor = investors[_addr];
if(investor.depositTime > 0){
uint256 secPassed = now.sub(investor.depositTime);
uint256 grm = getRateMultiplier();
uint256 calculateProfit;
if (secPassed > 0) {
calculateProfit = (investor.trxDeposit.mul(secPassed.mul(grm))).div(timeDevider);
}
if (calculateProfit.add(investor.profitGained) >= investor.trxDeposit.mul(3)){
return investor.trxDeposit.mul(3);
}
else{
return calculateProfit.add(investor.profitGained);
}
} else {
return 0;
}
}
function getRateMultiplier() public view returns (uint256) {
Investor storage investor = investors[msg.sender];
uint256 grm = 116000*2 ; // 2% usual secnario
if(investor.depositTime > 0){
if(investor.howmuchPaid.add(investor.profitGained) > investor.trxDeposit){
grm = 116000 ; //1% after 100% capital achieved scenario
}
uint256 secPassed =0;
if(investor.depositTime > 0){
secPassed = now.sub(investor.depositTime);
}
if ((investor.trxDeposit.mul(secPassed.mul(grm))).div(timeDevider) > investor.trxDeposit) {
grm = 116000 ; //1% very rare scenario where no withdrawals happened for more than 50 days. then convert it to 1%
}
}
return grm;
}
function getterGlobal() public view returns(uint256, uint256, uint256, uint256) {
return (address(this).balance, globalNoOfInvestors, getRateMultiplier(), globalInvested);
}
function getterGlobal1() public view returns(uint256, uint256, uint256, uint256) {
return (presentLevelNumber,globalTokensGiven,globalTokensBurned, donated);
}
function getterInvestor1(address _addr) public view returns(uint256, uint256, uint256, uint256, uint256) {
uint256 totalWithdrawAvailable = 0;
if(investors[_addr].depositTime > 0) {
totalWithdrawAvailable = getProfit(_addr);
}
return (totalWithdrawAvailable, investors[_addr].trxDeposit, investors[_addr].depositTime, investors[_addr].profitGained, investors[_addr].howmuchPaid);
}
function getterInvestor3(address _addr) public view returns(uint256, uint256, uint256, uint256, address, uint256) {
return (investors[_addr].invested, investors[_addr].reinvested, investors[_addr].tokensIssued, investors[_addr].tokensBurned, investors[_addr].upline, investors[_addr].referralBonus);
}
function getterInvestor31(address _addr) public view returns(uint256, uint256) {
return (calculateSystemBurnRate(_addr), calculateMyBurnRate(_addr));
}
function getterInvestor4(address _addr) public view returns(uint256, uint256, uint256) {
return (investors[_addr].lastWithdrawTime, investors[_addr].depositTime, investors[_addr].basicUser);
}
function payUplines(uint256 _amount, address _upline) private{
uint256 _allbonus = (_amount.mul(10)).div(100);
address _upline1 = _upline;
address _upline2 = investors[_upline1].upline;
address _upline3 = investors[_upline2].upline;
address _upline4 = investors[_upline3].upline;
uint256 _referralBonus = 0;
if (_upline1 != address(0)) {
_referralBonus = (_amount.mul(5)).div(100);
_allbonus = _allbonus.sub(_referralBonus);
updateProfits(_upline1);
investors[_upline1].referralBonus = _referralBonus.add(investors[_upline1].referralBonus);
investors[_upline1].trxDeposit = _referralBonus.add(investors[_upline1].trxDeposit);
emit EvtReferralBonus(_upline1, msg.sender, 1, _referralBonus);
}
if (_upline2 != address(0)) {
_referralBonus = (_amount.mul(3)).div(100);
_allbonus = _allbonus.sub(_referralBonus);
updateProfits(_upline2);
investors[_upline2].referralBonus = _referralBonus.add(investors[_upline2].referralBonus);
investors[_upline2].trxDeposit = _referralBonus.add(investors[_upline2].trxDeposit);
emit EvtReferralBonus(_upline2, msg.sender, 2, _referralBonus);
}
if (_upline3 != address(0)) {
_referralBonus = (_amount.mul(1)).div(100);
_allbonus = _allbonus.sub(_referralBonus);
updateProfits(_upline3);
investors[_upline3].referralBonus = _referralBonus.add(investors[_upline3].referralBonus);
investors[_upline3].trxDeposit = _referralBonus.add(investors[_upline3].trxDeposit);
emit EvtReferralBonus(_upline3, msg.sender, 3, _referralBonus);
}
if (_upline4 != address(0)) {
_referralBonus = (_amount.mul(1)).div(100);
_allbonus = _allbonus.sub(_referralBonus);
updateProfits(_upline4);
investors[_upline4].referralBonus = _referralBonus.add(investors[_upline4].referralBonus);
investors[_upline4].trxDeposit = _referralBonus.add(investors[_upline4].trxDeposit);
emit EvtReferralBonus(_upline4, msg.sender, 4, _referralBonus);
}
if(_allbonus > 0){
_referralBonus = _allbonus;
updateProfits(contractOwner);
investors[contractOwner].referralBonus = _referralBonus.add(investors[contractOwner].referralBonus);
investors[contractOwner].trxDeposit = _referralBonus.add(investors[contractOwner].trxDeposit);
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address _to, uint256 _amount) external;
function burn(address _to, uint256 _amount) external;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IJustswapExchange {
function () external payable;
function trxToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns(uint256);
}
| 296,816 | 806 |
e28040af28cb596c043483783dee80626e4032b708c1c2d4e606c1852208e5bd
| 25,271 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/33/339C35C38fd6f0a150a2a1CB983cdf43c915c4E5_Treasury.sol
| 5,533 | 22,262 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function 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;
}
}
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 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 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 {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(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) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IERC20Mintable {
function mint(uint256 amount_) external;
function mint(address account_, uint256 ammount_) external;
}
interface IOHMERC20 {
function burnFrom(address account_, uint256 amount_) external;
}
interface IBondCalculator {
function valuation(address pair_, uint amount_) external view returns (uint _value);
}
contract Treasury is Ownable {
using SafeMath for uint;
using SafeERC20 for IERC20;
event Deposit(address indexed token, uint amount, uint value);
event Withdrawal(address indexed token, uint amount, uint value);
event CreateDebt(address indexed debtor, address indexed token, uint amount, uint value);
event RepayDebt(address indexed debtor, address indexed token, uint amount, uint value);
event ReservesManaged(address indexed token, uint amount);
event ReservesUpdated(uint indexed totalReserves);
event ReservesAudited(uint indexed totalReserves);
event RewardsMinted(address indexed caller, address indexed recipient, uint amount);
event ChangeQueued(MANAGING indexed managing, address queued);
event ChangeActivated(MANAGING indexed managing, address activated, bool result);
enum MANAGING {RESERVEDEPOSITOR, RESERVESPENDER, RESERVETOKEN, RESERVEMANAGER, LIQUIDITYDEPOSITOR, LIQUIDITYTOKEN, LIQUIDITYMANAGER, DEBTOR, REWARDMANAGER, SOHM}
address public immutable OHM;
uint public immutable blocksNeededForQueue;
address[] public reserveTokens; // Push only, beware false-positives.
mapping(address => bool) public isReserveToken;
mapping(address => uint) public reserveTokenQueue; // Delays changes to mapping.
address[] public reserveDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveDepositor;
mapping(address => uint) public reserveDepositorQueue; // Delays changes to mapping.
address[] public reserveSpenders; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveSpender;
mapping(address => uint) public reserveSpenderQueue; // Delays changes to mapping.
address[] public liquidityTokens; // Push only, beware false-positives.
mapping(address => bool) public isLiquidityToken;
mapping(address => uint) public LiquidityTokenQueue; // Delays changes to mapping.
address[] public liquidityDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityDepositor;
mapping(address => uint) public LiquidityDepositorQueue; // Delays changes to mapping.
mapping(address => address) public bondCalculator; // bond calculator for liquidity token
address[] public reserveManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveManager;
mapping(address => uint) public ReserveManagerQueue; // Delays changes to mapping.
address[] public liquidityManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityManager;
mapping(address => uint) public LiquidityManagerQueue; // Delays changes to mapping.
address[] public debtors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isDebtor;
mapping(address => uint) public debtorQueue; // Delays changes to mapping.
mapping(address => uint) public debtorBalance;
address[] public rewardManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isRewardManager;
mapping(address => uint) public rewardManagerQueue; // Delays changes to mapping.
address public sOHM;
uint public sOHMQueue; // Delays change to sOHM address
uint public totalReserves; // Risk-free value of all assets
uint public totalDebt;
constructor (address _OHM,
address _MIM,
uint _blocksNeededForQueue) {
require(_OHM != address(0));
OHM = _OHM;
isReserveToken[_MIM] = true;
reserveTokens.push(_MIM);
blocksNeededForQueue = _blocksNeededForQueue;
}
function deposit(uint _amount, address _token, uint _profit) external returns (uint send_) {
require(isReserveToken[_token] || isLiquidityToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
if (isReserveToken[_token]) {
require(isReserveDepositor[msg.sender], "Not approved");
} else {
require(isLiquidityDepositor[msg.sender], "Not approved");
}
uint value = valueOf(_token, _amount);
// mint OHM needed and store amount of rewards for distribution
send_ = value.sub(_profit);
IERC20Mintable(OHM).mint(msg.sender, send_);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit Deposit(_token, _amount, value);
}
function withdraw(uint _amount, address _token) external {
require(isReserveToken[_token], "Not accepted");
// Only reserves can be used for redemptions
require(isReserveSpender[msg.sender] == true, "Not approved");
uint value = valueOf(_token, _amount);
IOHMERC20(OHM).burnFrom(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit Withdrawal(_token, _amount, value);
}
function incurDebt(uint _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
uint value = valueOf(_token, _amount);
uint maximumDebt = IERC20(sOHM).balanceOf(msg.sender);
// Can only borrow against sOHM held
uint availableDebt = maximumDebt.sub(debtorBalance[msg.sender]);
require(value <= availableDebt, "Exceeds debt limit");
debtorBalance[msg.sender] = debtorBalance[msg.sender].add(value);
totalDebt = totalDebt.add(value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).transfer(msg.sender, _amount);
emit CreateDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithReserve(uint _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
uint value = valueOf(_token, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(value);
totalDebt = totalDebt.sub(value);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit RepayDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithOHM(uint _amount) external {
require(isDebtor[msg.sender], "Not approved");
IOHMERC20(OHM).burnFrom(msg.sender, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(_amount);
totalDebt = totalDebt.sub(_amount);
emit RepayDebt(msg.sender, OHM, _amount, _amount);
}
function manage(address _token, uint _amount) external {
if (isLiquidityToken[_token]) {
require(isLiquidityManager[msg.sender], "Not approved");
} else {
require(isReserveManager[msg.sender], "Not approved");
}
uint value = valueOf(_token, _amount);
require(value <= excessReserves(), "Insufficient reserves");
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit ReservesManaged(_token, _amount);
}
function mintRewards(address _recipient, uint _amount) external {
require(isRewardManager[msg.sender], "Not approved");
require(_amount <= excessReserves(), "Insufficient reserves");
IERC20Mintable(OHM).mint(_recipient, _amount);
emit RewardsMinted(msg.sender, _recipient, _amount);
}
function excessReserves() public view returns (uint) {
return totalReserves.sub(IERC20(OHM).totalSupply().sub(totalDebt));
}
function auditReserves() external onlyManager() {
uint reserves;
for (uint i = 0; i < reserveTokens.length; i++) {
reserves = reserves.add(valueOf(reserveTokens[i], IERC20(reserveTokens[i]).balanceOf(address(this))));
}
for (uint i = 0; i < liquidityTokens.length; i++) {
reserves = reserves.add(valueOf(liquidityTokens[i], IERC20(liquidityTokens[i]).balanceOf(address(this))));
}
totalReserves = reserves;
emit ReservesUpdated(reserves);
emit ReservesAudited(reserves);
}
function valueOf(address _token, uint _amount) public view returns (uint value_) {
if (isReserveToken[_token]) {
// convert amount to match OHM decimals
value_ = _amount.mul(10 ** IERC20(OHM).decimals()).div(10 ** IERC20(_token).decimals());
} else if (isLiquidityToken[_token]) {
value_ = IBondCalculator(bondCalculator[_token]).valuation(_token, _amount);
}
}
function queue(MANAGING _managing, address _address) external onlyManager() returns (bool) {
require(_address != address(0));
if (_managing == MANAGING.RESERVEDEPOSITOR) {// 0
reserveDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVESPENDER) {// 1
reserveSpenderQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVETOKEN) {// 2
reserveTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVEMANAGER) {// 3
ReserveManagerQueue[_address] = block.number.add(blocksNeededForQueue.mul(2));
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {// 4
LiquidityDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {// 5
LiquidityTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {// 6
LiquidityManagerQueue[_address] = block.number.add(blocksNeededForQueue.mul(2));
} else if (_managing == MANAGING.DEBTOR) {// 7
debtorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.REWARDMANAGER) {// 8
rewardManagerQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.SOHM) {// 9
sOHMQueue = block.number.add(blocksNeededForQueue);
} else return false;
emit ChangeQueued(_managing, _address);
return true;
}
function toggle(MANAGING _managing, address _address, address _calculator) external onlyManager() returns (bool) {
require(_address != address(0));
bool result;
if (_managing == MANAGING.RESERVEDEPOSITOR) {// 0
if (requirements(reserveDepositorQueue, isReserveDepositor, _address)) {
reserveDepositorQueue[_address] = 0;
if (!listContains(reserveDepositors, _address)) {
reserveDepositors.push(_address);
}
}
result = !isReserveDepositor[_address];
isReserveDepositor[_address] = result;
} else if (_managing == MANAGING.RESERVESPENDER) {// 1
if (requirements(reserveSpenderQueue, isReserveSpender, _address)) {
reserveSpenderQueue[_address] = 0;
if (!listContains(reserveSpenders, _address)) {
reserveSpenders.push(_address);
}
}
result = !isReserveSpender[_address];
isReserveSpender[_address] = result;
} else if (_managing == MANAGING.RESERVETOKEN) {// 2
if (requirements(reserveTokenQueue, isReserveToken, _address)) {
reserveTokenQueue[_address] = 0;
if (!listContains(reserveTokens, _address)) {
reserveTokens.push(_address);
}
}
result = !isReserveToken[_address];
isReserveToken[_address] = result;
} else if (_managing == MANAGING.RESERVEMANAGER) {// 3
if (requirements(ReserveManagerQueue, isReserveManager, _address)) {
reserveManagers.push(_address);
ReserveManagerQueue[_address] = 0;
if (!listContains(reserveManagers, _address)) {
reserveManagers.push(_address);
}
}
result = !isReserveManager[_address];
isReserveManager[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {// 4
if (requirements(LiquidityDepositorQueue, isLiquidityDepositor, _address)) {
liquidityDepositors.push(_address);
LiquidityDepositorQueue[_address] = 0;
if (!listContains(liquidityDepositors, _address)) {
liquidityDepositors.push(_address);
}
}
result = !isLiquidityDepositor[_address];
isLiquidityDepositor[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {// 5
if (requirements(LiquidityTokenQueue, isLiquidityToken, _address)) {
LiquidityTokenQueue[_address] = 0;
if (!listContains(liquidityTokens, _address)) {
liquidityTokens.push(_address);
}
}
result = !isLiquidityToken[_address];
isLiquidityToken[_address] = result;
bondCalculator[_address] = _calculator;
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {// 6
if (requirements(LiquidityManagerQueue, isLiquidityManager, _address)) {
LiquidityManagerQueue[_address] = 0;
if (!listContains(liquidityManagers, _address)) {
liquidityManagers.push(_address);
}
}
result = !isLiquidityManager[_address];
isLiquidityManager[_address] = result;
} else if (_managing == MANAGING.DEBTOR) {// 7
if (requirements(debtorQueue, isDebtor, _address)) {
debtorQueue[_address] = 0;
if (!listContains(debtors, _address)) {
debtors.push(_address);
}
}
result = !isDebtor[_address];
isDebtor[_address] = result;
} else if (_managing == MANAGING.REWARDMANAGER) {// 8
if (requirements(rewardManagerQueue, isRewardManager, _address)) {
rewardManagerQueue[_address] = 0;
if (!listContains(rewardManagers, _address)) {
rewardManagers.push(_address);
}
}
result = !isRewardManager[_address];
isRewardManager[_address] = result;
} else if (_managing == MANAGING.SOHM) {// 9
sOHMQueue = 0;
sOHM = _address;
result = true;
} else return false;
emit ChangeActivated(_managing, _address, result);
return true;
}
function requirements(mapping(address => uint) storage queue_,
mapping(address => bool) storage status_,
address _address) internal view returns (bool) {
if (!status_[_address]) {
require(queue_[_address] != 0, "Must queue");
require(queue_[_address] <= block.number, "Queue not expired");
return true;
}
return false;
}
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for (uint i = 0; i < _list.length; i++) {
if (_list[i] == _token) {
return true;
}
}
return false;
}
}
| 75,565 | 807 |
065c5e01c020663091777dd31f85150526a1ab170e916507276e0e0b1fe9bca4
| 10,601 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Unchecked_send/Sol/buggy_25.sol
| 3,218 | 10,499 |
pragma solidity ^0.5.11;
//
// * whitebetting.com - the whitest football betting game based on ethereum blockchain
// on 2019-09-24
//
contract WhiteBetting {
function bug_unchk_send28() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
address payable public owner;
// Game information
struct GameInfo {
// game start time
uint256 timestamp;
// game odds
uint32 odd_homeTeam;
uint32 odd_drawTeam;
uint32 odd_awayTeam;
uint32 odd_over;
uint32 odd_under;
uint32 odd_homeTeamAndDraw;
uint32 odd_homeAndAwayTeam;
uint32 odd_awayTeamAndDraw;
// Checking the game status
uint8 open_status;
// Checking whether winning were paid
bool isDone;
}
function bug_unchk_send27() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
mapping(uint64 => GameInfo) public gameList;
// Player betting infomation
struct BetFixture {
address payable player;
uint256 stake;
uint32 odd;
// betting type
uint16 selectedTeam;
}
function bug_unchk_send26() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
mapping(uint64 => BetFixture[]) public betList;
// Events that are issued to make statistic recovery easier
function bug_unchk15(address payable addr) public
{addr.send (42 ether); } //Unchecked_send bug
event Success(uint256 odd);
function unhandledsend_unchk14(address payable callee) public {
callee.send(5 ether); //Unchecked_send bug
}
event Deposit(address sender, uint256 eth);
function callnotchecked_unchk13(address callee) public {
callee.call.value(1 ether); //Unchecked_send bug
}
event Withdraw(address receiver, uint256 eth);
function my_func_uncheck12(address payable dst) public payable{
dst.call.value(msg.value)(""); //Unchecked_send bug
}
event NewStake(address player, uint64 fixtureId, uint16 selectedTeam, uint256 stake, uint256 odd);
function my_func_unchk11(address payable dst) public payable{
dst.send(msg.value); //Unchecked_send bug
}
event SetGame(uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status);
function cash_unchk10(uint roundIndex, uint subpotIndex,address payable winner_unchk10) public{
uint64 subpot_unchk10 = 10 ether;
winner_unchk10.send(subpot_unchk10); //bug //Unchecked_send bug
subpot_unchk10= 0;
}
event ChangeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw);
function callnotchecked_unchk1(address payable callee) public {
callee.call.value(2 ether); //Unchecked_send bug
}
event GivePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder);
// Constructor
constructor() public {
owner = msg.sender;
}
function bug_unchk_send25() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// Change the game status
function setOpenStatus(uint64 _fixtureId, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].open_status = _open_status;
}
function bug_unchk_send24() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// Refresh the game odd
function changeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw) external onlyOwner {
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
emit ChangeOdd (_fixtureId, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw);
}
function bug_unchk_send23() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// Save the game information
function setGameInfo (uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].timestamp = _timestamp;
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
gameList[_fixtureId].open_status = _open_status;
gameList[_fixtureId].isDone = false;
emit SetGame(_fixtureId, _timestamp, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw, _open_status);
}
function bug_unchk_send22() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// Player make a bet
function placeBet(uint64 _fixtureId, uint16 _selectedTeam, uint32 _odd) external payable {
uint stake = msg.value;
// Minium amount to bet is 0.001 ether
require(stake >= .001 ether);
// Check whether odds is valid
require(_odd != 0);
// Compare to match mainnet odds with was submitted odds by betting type
if (_selectedTeam == 1) {
require(gameList[_fixtureId].odd_homeTeam == _odd);
} else if (_selectedTeam == 2) {
require(gameList[_fixtureId].odd_drawTeam == _odd);
} else if (_selectedTeam == 3) {
require(gameList[_fixtureId].odd_awayTeam == _odd);
} else if (_selectedTeam == 4) {
require(gameList[_fixtureId].odd_over == _odd);
} else if (_selectedTeam == 5) {
require(gameList[_fixtureId].odd_under == _odd);
} else if (_selectedTeam == 6) {
require(gameList[_fixtureId].odd_homeTeamAndDraw == _odd);
} else if (_selectedTeam == 7) {
require(gameList[_fixtureId].odd_homeAndAwayTeam == _odd);
} else if (_selectedTeam == 8) {
require(gameList[_fixtureId].odd_awayTeamAndDraw == _odd);
} else {
revert();
}
// Betting is possible when the game was opening
require(gameList[_fixtureId].open_status == 3);
// Betting is possible only 10 min. ago
require(now < (gameList[_fixtureId].timestamp - 10 minutes));
// Save the betting information
betList[_fixtureId].push(BetFixture(msg.sender, stake, _odd, _selectedTeam));
emit NewStake(msg.sender, _fixtureId, _selectedTeam, stake, _odd);
}
function bug_unchk_send21() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// Give prize money by the game result
function givePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder) external onlyOwner payable {
// Check the game status whether is opening
require(gameList[_fixtureId].open_status == 3);
// Check if it has ever compensated
require(gameList[_fixtureId].isDone == false);
// Check if it has any player who betted
require(betList[_fixtureId][0].player != address(0));
// Give the prize money!
for (uint i= 0 ; i < betList[_fixtureId].length; i++){
uint16 selectedTeam = betList[_fixtureId][i].selectedTeam;
uint256 returnEth = (betList[_fixtureId][i].stake * betList[_fixtureId][i].odd) / 1000 ;
if ((selectedTeam == 1 && _homeDrawAway == 1)
|| (selectedTeam == 2 && _homeDrawAway == 2)
|| (selectedTeam == 3 && _homeDrawAway == 3)
|| (selectedTeam == 4 && _overUnder == 1)
|| (selectedTeam == 5 && _overUnder == 2)
|| (selectedTeam == 6 && (_homeDrawAway == 1 || _homeDrawAway == 2))
|| (selectedTeam == 7 && (_homeDrawAway == 1 || _homeDrawAway == 3))
|| (selectedTeam == 8 && (_homeDrawAway == 3 || _homeDrawAway == 2))){
betList[_fixtureId][i].player.transfer(returnEth);
}
}
// Change the game status.
gameList[_fixtureId].open_status = 5;
// It was paid.
gameList[_fixtureId].isDone = true; // true .
emit GivePrizeMoney(_fixtureId, _homeDrawAway, _overUnder);
}
function bug_unchk_send20() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
// Get this balance of CA
function getBalance() external view returns(uint){
return address(this).balance;
}
function unhandledsend_unchk2(address payable callee) public {
callee.send(5 ether); //Unchecked_send bug
}
// Deposit from owner to CA
function deposit(uint256 _eth) external payable{
emit Deposit(msg.sender, _eth);
}
function bug_unchk_send19() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// Change Owner
function changeOwner(address payable _newOwner) external onlyOwner {
owner = _newOwner;
}
function bug_unchk_send18() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// Fallback function
function () external payable{
owner.transfer(msg.value);
}
function bug_unchk_send17() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// Withdraw from CA to owner
function withdraw(uint256 _amount) external payable onlyOwner {
require(_amount > 0 && _amount <= address(this).balance);
owner.transfer(_amount);
emit Withdraw(owner, _amount);
}
function bug_unchk_send16() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
}
| 224,119 | 808 |
0c8f93174c1174dfa63387b06798290f4049b569179f34ffce7171e113a5f00e
| 15,498 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x712382Fa9ab3CDb2De71a23F4B6180d5B9d31739/contract.sol
| 2,927 | 10,778 |
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, uint256) external returns (bool);
function transfer(address, uint256) external returns (bool);
}
contract Pool_1 is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint256 amount);
// WHALE token contract address
address public tokenAddress = 0xfdF38187B8b7D092c345f8E53f37CD8D87453e0C;
// WBNB token contract address
address public WBNBtokenAddress = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
// reward rate 130 % per year
uint256 public rewardRate = 13000;
uint256 public rewardInterval = 365 days;
// staking fee 0%
uint256 public stakingFeeRate = 0;
// unstaking fee 0%
uint256 public unstakingFeeRate = 0;
// unstaking possible after 0 days
uint256 public cliffTime = 0 days;
uint256 public totalClaimedRewards = 0;
uint256 private stakingAndDaoTokens = 100000e18;
EnumerableSet.AddressSet private holders;
mapping (address => uint256) public depositedTokens;
mapping (address => uint256) public stakingTime;
mapping (address => uint256) public lastClaimedTime;
mapping (address => uint256) public totalEarnedTokens;
function updateAccount(address account) private {
uint256 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 (uint256) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint256 timeDiff = now.sub(lastClaimedTime[_holder]);
uint256 stakedAmount = depositedTokens[_holder];
uint256 pendingDivs = stakedAmount.mul(rewardRate).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
}
function getNumberOfHolders() public view returns (uint256) {
return holders.length();
}
function deposit(uint256 amountEthe) public payable {
require(amountEthe > 0, "Cannot deposit 0 Tokens");
updateAccount(msg.sender);
uint256 fee = amountEthe.mul(stakingFeeRate).div(1e4);
uint256 amountAfterFee = amountEthe.sub(fee);
require(Token(WBNBtokenAddress).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(uint256 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);
uint256 fee = amountToWithdraw.mul(unstakingFeeRate).div(1e4);
uint256 amountAfterFee = amountToWithdraw.sub(fee);
require(Token(WBNBtokenAddress).transfer(owner, fee), "Could not transfer deposit fee.");
require(Token(WBNBtokenAddress).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 getStakingAndDaoAmount() public view returns (uint256) {
if (totalClaimedRewards >= stakingAndDaoTokens) {
return 0;
}
uint256 remaining = stakingAndDaoTokens.sub(totalClaimedRewards);
return remaining;
}
function setTokenAddress(address _tokenAddressess) public onlyOwner {
tokenAddress = _tokenAddressess;
}
function setCliffTime(uint256 _time) public onlyOwner {
cliffTime = _time;
}
function setRewardInterval(uint256 _rewardInterval) public onlyOwner {
rewardInterval = _rewardInterval;
}
function setStakingAndDaoTokens(uint256 _stakingAndDaoTokens) public onlyOwner {
stakingAndDaoTokens = _stakingAndDaoTokens;
}
function setStakingFeeRate(uint256 _Fee) public onlyOwner {
stakingFeeRate = _Fee;
}
function setUnstakingFeeRate(uint256 _Fee) public onlyOwner {
unstakingFeeRate = _Fee;
}
function setRewardRate(uint256 _rewardRate) public onlyOwner {
rewardRate = _rewardRate;
}
// function to allow admin to claim *any* ERC20 tokens sent to this contract
function transferAnyERC20Tokens(address _tokenAddress, address _to, uint256 _amount) public onlyOwner {
require(_tokenAddress != WBNBtokenAddress);
Token(_tokenAddress).transfer(_to, _amount);
}
}
| 254,907 | 809 |
616f12b43dd450aa0e6ffa06cff772ccd44b5f73b47c7cdd0fdc479b673a50b3
| 18,661 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/DosByComplexFallback/manualCheck/0xbc425c4209bd4c3f1fc9686371513f13f72cc70a_dosByComplexFallback.sol
| 3,983 | 17,417 |
pragma solidity ^0.5.2;
library ToAddress {
function toAddr(uint _source) internal pure returns(address payable) {
return address(_source);
}
function toAddr(bytes memory _source) internal pure returns(address payable addr) {
// solium-disable security/no-inline-assembly
assembly { addr := mload(add(_source,0x14)) }
return addr;
}
function isNotContract(address addr) internal view returns(bool) {
// solium-disable security/no-inline-assembly
uint256 length;
assembly { length := extcodesize(addr) }
return length == 0;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// @wiki: https://theethereum.wiki/w/index.php/ERC20_Token_Standard
// ----------------------------------------------------------------------------
contract ERC20Interface {
function tokensOwner() public view returns (uint256);
function contracBalance() public view returns (uint256);
function balanceOf(address _tokenOwner) public view returns (uint256 balanceOwner);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event EtherTransfer(address indexed from, address indexed to, uint256 etherAmount);
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol.
// ----------------------------------------------------------------------------
contract ERC20 is ERC20Interface {
using SafeMath for uint;
using ToAddress for *;
string constant public symbol = "URA";
string constant public name = "URA market coin";
uint8 constant internal decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) balances;
// ------------------------------------------------------------------------
// Get balance on contract
// ------------------------------------------------------------------------
function contracBalance() public view returns (uint256 contractBalance) {
contractBalance = address(this).balance;
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address _tokenOwner) public view returns (uint256 balanceOwner) {
return balances[_tokenOwner];
}
// ------------------------------------------------------------------------
// Addon shows caller tokens.
// ------------------------------------------------------------------------
function tokensOwner() public view returns (uint256 tokens) {
tokens = balances[msg.sender];
}
}
// ----------------------------------------------------------------------------
// Bookeeper contract that holds the amount of dividents in Ether.
// ----------------------------------------------------------------------------
contract Dividend is ERC20 {
uint8 public constant dividendsCosts = 10; // Dividends 10%.
uint16 public constant day = 6000;
uint256 public dividendes; // storage for Dividends.
mapping(address => uint256) bookKeeper;
event SendOnDividend(address indexed customerAddress, uint256 dividendesAmount);
event WithdrawDividendes(address indexed customerAddress, uint256 dividendesAmount);
constructor() public {}
// ------------------------------------------------------------------------
// Withdraw dividendes.
// ------------------------------------------------------------------------
function withdrawDividendes() external payable returns(bool success) {
require(msg.sender.isNotContract(),
"the contract can not hold tokens");
uint256 _tokensOwner = balanceOf(msg.sender);
require(_tokensOwner > 0, "cannot pass 0 value");
require(bookKeeper[msg.sender] > 0,
"to withdraw dividends, please wait");
uint256 _dividendesAmount = dividendesCalc(_tokensOwner);
require(_dividendesAmount > 0, "dividendes amount > 0");
bookKeeper[msg.sender] = block.number;
dividendes = dividendes.sub(_dividendesAmount);
msg.sender.transfer(_dividendesAmount);
emit WithdrawDividendes(msg.sender, _dividendesAmount);
return true;
}
// ------------------------------------------------------------------------
// Get value of dividendes.
// ------------------------------------------------------------------------
function dividendesOf(address _owner)
public
view
returns(uint256 dividendesAmount) {
uint256 _tokens = balanceOf(_owner);
dividendesAmount = dividendesCalc(_tokens);
}
// ------------------------------------------------------------------------
// Count percent of dividendes from ether.
// ------------------------------------------------------------------------
function onDividendes(uint256 _value, uint8 _dividendsCosts)
internal
pure
returns(uint256 forDividendes) {
return _value.mul(_dividendsCosts).div(100);
}
// ------------------------------------------------------------------------
// Get number of dividendes in ether
// * @param _tokens: Amount customer tokens.
// * @param _dividendesPercent: Customer tokens percent in 10e18.
// *
// * @retunrs dividendesReceived: amount of dividendes in ether.
// ------------------------------------------------------------------------
function dividendesCalc(uint256 _tokensAmount)
internal
view
returns(uint256 dividendesReceived) {
if (_tokensAmount == 0) {
return 0;
}
uint256 _tokens = _tokensAmount.mul(10e18);
uint256 _dividendesPercent = dividendesPercent(_tokens); // Get % from tokensOwner.
dividendesReceived = dividendes.mul(_dividendesPercent).div(100);
dividendesReceived = dividendesReceived.div(10e18);
}
// ------------------------------------------------------------------------
// Get number of dividendes in percent
// * @param _tokens: Amount of (tokens * 10e18).
// * returns: tokens % in 10e18.
// ------------------------------------------------------------------------
function dividendesPercent(uint256 _tokens)
internal
view
returns(uint256 percent) {
if (_tokens == 0) {
return 0;
}
uint256 _interest = accumulatedInterest();
if (_interest > 100) {
_interest = 100;
}
percent = _tokens.mul(_interest).div(totalSupply);
}
// ------------------------------------------------------------------------
// Block value when buying.
// ------------------------------------------------------------------------
function accumulatedInterest() private view returns(uint256 interest) {
if (bookKeeper[msg.sender] == 0) {
interest = 0;
} else {
interest = block.number.sub(bookKeeper[msg.sender]).div(day);
}
}
}
// ----------------------------------------------------------------------------
// URA.market main contract.
// ----------------------------------------------------------------------------
contract URA is ERC20, Dividend {
// The initial cost of the token, it can not be less. //
uint128 constant tokenPriceInit = 0.00000000001 ether;
uint128 public constant limiter = 15 ether;
uint8 public constant advertisingCosts = 5; // 5% for transfer advertising.
uint8 public constant forReferralCosts = 2; // 2% for transfer to referral.
uint8 public constant forWithdrawCosts = 3; // 3% for the withdraw of tokens.
// For advertising. //
address payable constant advertising = 0x4d332E1f9d55d9B89dc2a8457B693Beaa7b36b2e;
event WithdrawTokens(address indexed customerAddress, uint256 ethereumWithdrawn);
event ReverseAccess(uint256 etherAmount);
event ForReferral(uint256 etherAmount);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public { }
// ------------------------------------------------------------------------
// Purchase
// * @param _reverseAccessOfLimiter: Excess value.
// * @param _aTokenPrice: Price For one token.
// * @param _forAdvertising: Advertising victim.
// * @param _forDividendes: Dividend sacrifice.
// * @param _amountOfTokens: Ether to tokens amount.
// * @param _reverseAccess: Change remainder in ether.
// ------------------------------------------------------------------------
function () external payable { //inject DOS BY COMPLEX FALLBACK
require(msg.sender.isNotContract(),
"the contract can not hold tokens");
address payable _referralAddress = msg.data.toAddr();
uint256 _incomingEthereum = msg.value;
uint256 _forReferral;
uint256 _reverseAccessOfLimiter;
if (_incomingEthereum > limiter) {
_reverseAccessOfLimiter = _incomingEthereum.sub(limiter);
_incomingEthereum = limiter;
}
uint256 _aTokenPrice = tokenPrice();
uint256 _dividendesOwner = dividendesOf(msg.sender);
uint256 _forAdvertising = _incomingEthereum.mul(advertisingCosts).div(100);
uint256 _forDividendes = onDividendes(_incomingEthereum, dividendsCosts);
if (_referralAddress != address(0)) {
_forReferral = _incomingEthereum.mul(forReferralCosts).div(100);
_forAdvertising = _forAdvertising.sub(_forReferral);
}
_incomingEthereum = _incomingEthereum.sub(_forDividendes).sub(_forAdvertising).sub(_forReferral);
require(_incomingEthereum >= _aTokenPrice,
"the amount of ether is not enough");
(uint256 _amountOfTokens,
uint256 _reverseAccess) = ethereumToTokens(_incomingEthereum, _aTokenPrice);
advertising.call.gas(2301).value(_forAdvertising)("");
_reverseAccessOfLimiter = _reverseAccessOfLimiter.add(_reverseAccess);
if (_reverseAccessOfLimiter > 0) {
// If there are leftovers, then return to customer. //
msg.sender.call.gas(2301).value(_reverseAccessOfLimiter)("");
emit ReverseAccess(_reverseAccessOfLimiter);
}
if (_forReferral > 0 && _referralAddress != address(0)) {
_referralAddress.call.gas(2301).value(_forReferral)("");
emit ForReferral(_forReferral);
}
if (_dividendesOwner > _aTokenPrice) {
reinvest();
}
bookKeeper[msg.sender] = block.number;
balances[msg.sender] = balances[msg.sender].add(_amountOfTokens);
totalSupply = totalSupply.add(_amountOfTokens);
dividendes = dividendes.add(_forDividendes);
emit EtherTransfer(msg.sender, advertising, _forAdvertising);
emit Transfer(address(0), msg.sender, _amountOfTokens);
emit SendOnDividend(msg.sender, _forDividendes);
}
// ------------------------------------------------------------------------
// Increment for token cost
// - Dynamic property that is responsible for
// - the rise and fall of the price of the token.
// ------------------------------------------------------------------------
function tokenPrice() public view returns(uint256 priceForToken) {
uint256 _contracBalance = contracBalance();
if (totalSupply == 0 || _contracBalance == 0) {
return tokenPriceInit;
}
return _contracBalance.div(totalSupply).mul(4).div(3);
}
// ------------------------------------------------------------------------
// Burning tokens function
// * @param _valueTokens: Amount tokens for burning.
// * @param _aTokenPrice: One token price.
// * @param _etherForTokens: Calculate the ether for burning tokens.
// * @param _forDividendes: Calculate the are common Dividendes.
// * @param _contracBalance: Get contract balance.
// * @param _dividendesAmount: Get the percentage of dividends burned tokens.
// ------------------------------------------------------------------------
function withdraw(uint256 _valueTokens) external payable returns(bool success) {
require(msg.sender.isNotContract(),
"the contract can not hold tokens");
uint256 _tokensOwner = balanceOf(msg.sender);
require(_valueTokens > 0, "cannot pass 0 value");
require(_tokensOwner >= _valueTokens,
"you do not have so many tokens");
uint256 _aTokenPrice = tokenPrice();
uint256 _etherForTokens = tokensToEthereum(_valueTokens, _aTokenPrice);
uint256 _contracBalance = contracBalance();
uint256 _forDividendes = onDividendes(_etherForTokens, forWithdrawCosts);
uint256 _dividendesAmount = dividendesCalc(_tokensOwner);
_etherForTokens = _etherForTokens.sub(_forDividendes);
totalSupply = totalSupply.sub(_valueTokens);
if (_dividendesAmount > 0) {
dividendes = dividendes.sub(_dividendesAmount);
_etherForTokens = _etherForTokens.add(_dividendesAmount);
emit WithdrawDividendes(msg.sender, _dividendesAmount);
}
if (_tokensOwner == _valueTokens) {
// if the owner out of system //
bookKeeper[msg.sender] = 0;
balances[msg.sender] = 0;
} else {
bookKeeper[msg.sender] = block.number;
balances[msg.sender] = balances[msg.sender].sub(_valueTokens);
}
if (_etherForTokens > _contracBalance) {
_etherForTokens = _contracBalance;
}
msg.sender.transfer(_etherForTokens);
emit WithdrawTokens(msg.sender, _etherForTokens);
emit SendOnDividend(address(0), _forDividendes);
return true;
}
// ------------------------------------------------------------------------
// Reinvest dividends into tokens
// ------------------------------------------------------------------------
function reinvest() public payable returns(bool success) {
require(msg.sender.isNotContract(),
"the contract can not hold tokens");
uint256 _dividendes = dividendesOf(msg.sender);
uint256 _aTokenPrice = tokenPrice();
require(_dividendes >= _aTokenPrice, "not enough dividends");
(uint256 _amountOfTokens,
uint256 _reverseAccess) = ethereumToTokens(_dividendes, _aTokenPrice);
require(_amountOfTokens > 0, "tokens amount not zero");
dividendes = dividendes.sub(_dividendes.sub(_reverseAccess));
balances[msg.sender] = balances[msg.sender].add(_amountOfTokens);
totalSupply = totalSupply.add(_amountOfTokens);
bookKeeper[msg.sender] = block.number;
emit Transfer(address(0), msg.sender, _amountOfTokens);
return true;
}
// ------------------------------------------------------------------------
// ether conversion to token
// ------------------------------------------------------------------------
function ethereumToTokens(uint256 _incomingEthereum, uint256 _aTokenPrice)
private
pure
returns(uint256 tokensReceived, uint256 reverseAccess) {
require(_incomingEthereum >= _aTokenPrice,
"input ether > a token price");
tokensReceived = _incomingEthereum.div(_aTokenPrice);
require(tokensReceived > 0, "you can not buy 0 tokens");
reverseAccess = _incomingEthereum.sub(tokensReceived.mul(_aTokenPrice));
}
// ------------------------------------------------------------------------
// Inverse function ethereumToTokens (Token conversion to ether).
// ------------------------------------------------------------------------
function tokensToEthereum(uint256 _tokens, uint256 _aTokenPrice)
private
pure
returns(uint256 etherReceived) {
require(_tokens > 0, "0 tokens cannot be counted");
etherReceived = _aTokenPrice.mul(_tokens);
}
}
| 278,034 | 810 |
1f034d6cb662f6fb9707a876f6d9ee8d470d6182858d7360691dbc1034ad3696
| 31,794 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ef/efb2e54B1D9BBB844dcFcC0D211e8280627d70b6_TheWell.sol
| 5,673 | 20,118 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner,"you are not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),"newowner not 0 address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/Whitelist.sol
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
mapping(address=>bool) public blackList;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'no whitelist');
_;
}
modifier noBlackList(){
require(!blackList[msg.sender]==true,"No Blacklist calls");
_;
}
function removeFromBlackList(address[] memory blackListAddress) public onlyOwner {
for(uint256 i;i<blackListAddress.length;i++){
blackList[blackListAddress[i]]=false;
}
}
function addToBlackList(address[] memory blackListAddress) public onlyOwner {
for(uint256 i;i<blackListAddress.length;i++){
blackList[blackListAddress[i]]=true;
}
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
return success;
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
}
contract BEP20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 internal _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0),"to address will not be 0");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0),"2");
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0),"3");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0),"4");
require(owner != address(0),"5");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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;
}
}
interface IToken {
function calculateTransferTaxes(address _from, uint256 _value) external view returns (uint256 adjustedValue, uint256 taxAmount);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function burn(uint256 _value) external;
}
contract TheWell is BEP20, Whitelist {
string public constant name = "Splash Liquidity Token";
string public constant symbol = "DROPS";
uint8 public constant decimals = 18;
// Variables
IToken internal token; // address of the BEP20 token traded on this contract
uint256 public totalTxs;
uint256 internal lastBalance_;
uint256 internal trackingInterval_ = 1 minutes;
uint256 public providers;
mapping (address => bool) internal _providers;
mapping (address => uint256) internal _txs;
bool public isPaused = true;
// Events
event onTokenPurchase(address indexed buyer, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onBnbPurchase(address indexed buyer, uint256 indexed token_amount, uint256 indexed bnb_amount);
event onAddLiquidity(address indexed provider, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onRemoveLiquidity(address indexed provider, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onLiquidity(address indexed provider, uint256 indexed amount);
event onContractBalance(uint256 balance);
event onPrice(uint256 price);
event onSummary(uint256 liquidity, uint256 price);
constructor (address token_addr) Ownable() public {
token = IToken(token_addr);
lastBalance_= now;
}
function unpause() public onlyOwner {
isPaused = false;
}
function pause() public onlyOwner {
isPaused = true;
}
modifier isNotPaused() {
require(!isPaused, "Swaps currently paused");
_;
}
receive() external payable {
bnbToTokenInput(msg.value, 1, msg.sender, msg.sender);
}
function getInputPrice(uint256 input_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0, "INVALID_VALUE");
uint256 input_amount_with_fee = input_amount.mul(990);
uint256 numerator = input_amount_with_fee.mul(output_reserve);
uint256 denominator = input_reserve.mul(1000).add(input_amount_with_fee);
return numerator / denominator;
}
function getOutputPrice(uint256 output_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0,"input_reserve & output reserve must >0");
uint256 numerator = input_reserve.mul(output_amount).mul(1000);
uint256 denominator = (output_reserve.sub(output_amount)).mul(990);
return (numerator / denominator).add(1);
}
function bnbToTokenInput(uint256 bnb_sold, uint256 min_tokens, address buyer, address recipient) private returns (uint256) {
require(bnb_sold > 0 && min_tokens > 0, "sold and min 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_bought = getInputPrice(bnb_sold, address(this).balance.sub(bnb_sold), token_reserve);
require(tokens_bought >= min_tokens, "tokens_bought >= min_tokens");
require(token.transfer(recipient, tokens_bought), "transfer err");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
emit onContractBalance(bnbBalance());
trackGlobalStats();
return tokens_bought;
}
function bnbToTokenSwapInput(uint256 min_tokens) public payable noBlackList isNotPaused returns (uint256) {
return bnbToTokenInput(msg.value, min_tokens,msg.sender, msg.sender);
}
function bnbToTokenOutput(uint256 tokens_bought, uint256 max_bnb, address buyer, address recipient) private returns (uint256) {
require(tokens_bought > 0 && max_bnb > 0,"tokens_bought > 0 && max_bnb >");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought, address(this).balance.sub(max_bnb), token_reserve);
// Throws if bnb_sold > max_bnb
uint256 bnb_refund = max_bnb.sub(bnb_sold);
if (bnb_refund > 0) {
payable(buyer).transfer(bnb_refund);
}
require(token.transfer(recipient, tokens_bought),"error");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
trackGlobalStats();
return bnb_sold;
}
function bnbToTokenSwapOutput(uint256 tokens_bought) public payable noBlackList isNotPaused returns (uint256) {
return bnbToTokenOutput(tokens_bought, msg.value, msg.sender, msg.sender);
}
function tokenToBnbInput(uint256 tokens_sold, uint256 min_bnb, address buyer, address recipient) private returns (uint256) {
require(tokens_sold > 0 && min_bnb > 0,"tokens_sold > 0 && min_bnb > 0");
uint256 token_reserve = token.balanceOf(address(this));
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
uint256 bnb_bought = getInputPrice(realized_sold, token_reserve, address(this).balance);
require(bnb_bought >= min_bnb,"bnb_bought >= min_bnb");
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transforfrom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return bnb_bought;
}
function tokenToBnbSwapInput(uint256 tokens_sold, uint256 min_bnb) public noBlackList isNotPaused returns (uint256) {
return tokenToBnbInput(tokens_sold, min_bnb, msg.sender, msg.sender);
}
function tokenToBnbOutput(uint256 bnb_bought, uint256 max_tokens, address buyer, address recipient) private returns (uint256) {
require(bnb_bought > 0,"bnb_bought > 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_sold = getOutputPrice(bnb_bought, token_reserve, address(this).balance);
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
tokens_sold += taxAmount;
// tokens sold is always > 0
require(max_tokens >= tokens_sold, 'max tokens exceeded');
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transorfroom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return tokens_sold;
}
function tokenToBnbSwapOutput(uint256 bnb_bought, uint256 max_tokens) public noBlackList isNotPaused returns (uint256) {
return tokenToBnbOutput(bnb_bought, max_tokens, msg.sender, msg.sender);
}
function trackGlobalStats() private {
uint256 price = getBnbToTokenOutputPrice(1e18);
uint256 balance = bnbBalance();
if (now.safeSub(lastBalance_) > trackingInterval_) {
emit onSummary(balance * 2, price);
lastBalance_ = now;
}
emit onContractBalance(balance);
emit onPrice(price);
totalTxs += 1;
_txs[msg.sender] += 1;
}
function getBnbToTokenInputPrice(uint256 bnb_sold) public view returns (uint256) {
require(bnb_sold > 0,"bnb_sold > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
return getInputPrice(bnb_sold, address(this).balance, token_reserve);
}
function getBnbToTokenOutputPrice(uint256 tokens_bought) public view returns (uint256) {
require(tokens_bought > 0,"tokens_bought > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought, address(this).balance, token_reserve);
return bnb_sold;
}
function getTokenToBnbInputPrice(uint256 tokens_sold) public view returns (uint256) {
require(tokens_sold > 0, "token sold < 0,,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_bought = getInputPrice(tokens_sold, token_reserve, address(this).balance);
return bnb_bought;
}
function getTokenToBnbOutputPrice(uint256 bnb_bought) public view returns (uint256) {
require(bnb_bought > 0,"bnb_bought > 0,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
return getOutputPrice(bnb_bought, token_reserve, address(this).balance);
}
function tokenAddress() public view returns (address) {
return address(token);
}
function bnbBalance() public view returns (uint256) {
return address(this).balance;
}
function tokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function getBnbToLiquidityInputPrice(uint256 bnb_sold) public view returns (uint256){
require(bnb_sold > 0,"bnb_sold > 0,,,,,3");
uint256 token_amount = 0;
uint256 total_liquidity = _totalSupply;
uint256 bnb_reserve = address(this).balance;
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (bnb_sold.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = bnb_sold.mul(total_liquidity) / bnb_reserve;
return liquidity_minted;
}
function getLiquidityToReserveInputPrice(uint amount) public view returns (uint256, uint256){
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0,"total_liquidity > 0,,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
return (bnb_amount, token_amount);
}
function txs(address owner) public view returns (uint256) {
return _txs[owner];
}
function addLiquidity(uint256 min_liquidity, uint256 max_tokens) noBlackList isNotPaused public payable returns (uint256) {
require(max_tokens > 0 && msg.value > 0, "Swap#addLiquidity: INVALID_ARGUMENT");
uint256 total_liquidity = _totalSupply;
uint256 token_amount = 0;
if (_providers[msg.sender] == false){
_providers[msg.sender] = true;
providers += 1;
}
if (total_liquidity > 0) {
require(min_liquidity > 0,"min_liquidity > 0,,,,4");
uint256 bnb_reserve = address(this).balance.sub(msg.value);
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (msg.value.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = msg.value.mul(total_liquidity) / bnb_reserve;
require(max_tokens >= token_amount && liquidity_minted >= min_liquidity,"max_tokens >= token_amount && liquidity_minted >= min_liquidity,,,,1");
_balances[msg.sender] = _balances[msg.sender].add(liquidity_minted);
_totalSupply = total_liquidity.add(liquidity_minted);
require(token.transferFrom(msg.sender, address(this), token_amount),"transfrom4 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, liquidity_minted);
return liquidity_minted;
} else {
require(msg.value >= 1e18, "INVALID_VALUE");
token_amount = max_tokens;
uint256 initial_liquidity = address(this).balance;
_totalSupply = initial_liquidity;
_balances[msg.sender] = initial_liquidity;
require(token.transferFrom(msg.sender, address(this), token_amount),"transforfrom 5 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, initial_liquidity);
return initial_liquidity;
}
}
function removeLiquidity(uint256 amount, uint256 min_bnb, uint256 min_tokens) onlyWhitelisted public returns (uint256, uint256) {
require(amount > 0 && min_bnb > 0 && min_tokens > 0,"amount > 0 && min_bnb > 0 && min_tokens > 0,333");
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0);
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
require(bnb_amount >= min_bnb && token_amount >= min_tokens,"(bnb_amount >= min_bnb && token_amount >= min_tokens,33");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_totalSupply = total_liquidity.sub(amount);
msg.sender.transfer(bnb_amount);
require(token.transfer(msg.sender, token_amount),"transfer error");
emit onRemoveLiquidity(msg.sender, bnb_amount, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(msg.sender, address(0), amount);
return (bnb_amount, token_amount);
}
}
//splash token 0x4ec58f9D205F9c919920313932cc71EC68d123C7
| 122,586 | 811 |
97f718c691b29a6907a380ce776d9f8cb9e797bb8c2351a1e2c3cd0d0a953548
| 32,519 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4d0269b1898bee6aa94f54d1724f9862aabdd010.sol
| 5,181 | 18,878 |
pragma solidity 0.4.23;
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// 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/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// 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/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
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/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
// File: zeppelin-solidity/contracts/token/ERC20/PausableToken.sol
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// File: contracts/REBToken.sol
contract REBToken is PausableToken, MintableToken {
string public name = "REBGLO Token";
string public symbol = "REB";
uint8 public decimals = 18;
function REBToken() public {
pause();
}
function checkBalanceTier(address holderAddress) public view returns(string) {
uint256 holderBalance = balanceOf(holderAddress);
if (holderBalance >= 1000000e18) {
return "Platinum tier";
} else if (holderBalance >= 700000e18) {
return "Gold tier";
} else if (holderBalance >= 300000e18) {
return "Titanium tier";
} else if (holderBalance == 0) {
return "Possess no REB";
}
return "Free tier";
}
}
// File: contracts/LockTokenAllocation.sol
contract LockTokenAllocation is Ownable {
using SafeMath for uint;
uint256 public unlockedAt;
uint256 public canSelfDestruct;
uint256 public tokensCreated;
uint256 public allocatedTokens;
uint256 public totalLockTokenAllocation;
mapping (address => uint256) public lockedAllocations;
REBToken public REB;
function LockTokenAllocation
(REBToken _token,
uint256 _unlockedAt,
uint256 _canSelfDestruct,
uint256 _totalLockTokenAllocation)
public
{
require(_token != address(0));
REB = REBToken(_token);
unlockedAt = _unlockedAt;
canSelfDestruct = _canSelfDestruct;
totalLockTokenAllocation = _totalLockTokenAllocation;
}
function addLockTokenAllocation(address beneficiary, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(lockedAllocations[beneficiary] == 0 && beneficiary != address(0)); // can only add once.
allocatedTokens = allocatedTokens.add(allocationValue);
require(allocatedTokens <= totalLockTokenAllocation);
lockedAllocations[beneficiary] = allocationValue;
return true;
}
function unlock() external {
require(REB != address(0));
assert(now >= unlockedAt);
// During first unlock attempt fetch total number of locked tokens.
if (tokensCreated == 0) {
tokensCreated = REB.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
// Will fail if allocation (and therefore toTransfer) is 0.
require(REB.transfer(msg.sender, transferAllocation));
}
function kill() public onlyOwner {
require(now >= canSelfDestruct);
uint256 balance = REB.balanceOf(this);
if (balance > 0) {
REB.transfer(msg.sender, balance);
}
selfdestruct(owner);
}
}
// File: zeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(now >= openingTime && now <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= now);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return now > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: zeppelin-solidity/contracts/crowdsale/distribution/FinalizableCrowdsale.sol
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/WhitelistedCrowdsale.sol
contract WhitelistedCrowdsale is Crowdsale, Ownable {
mapping(address => bool) public whitelist;
modifier isWhitelisted(address _beneficiary) {
require(whitelist[_beneficiary]);
_;
}
function addToWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = true;
}
function addManyToWhitelist(address[] _beneficiaries) external onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: contracts/REBCrowdsale.sol
contract REBCrowdsale is FinalizableCrowdsale, WhitelistedCrowdsale, Pausable {
uint256 constant public BOUNTY_SHARE = 125000000e18; // 125 M
uint256 constant public TEAM_SHARE = 2800000000e18; // 2.8 B
uint256 constant public ADVISOR_SHARE = 1750000000e18; // 1.75 B
uint256 constant public AIRDROP_SHARE = 200000000e18; // 200 M
uint256 constant public TOTAL_TOKENS_FOR_CROWDSALE = 5125000000e18; // 5.125 B
uint256 constant public PUBLIC_CROWDSALE_SOFT_CAP = 800000000e18; // 800 M
address public bountyWallet;
address public teamReserve;
address public advisorReserve;
address public airdrop;
// remainderPurchaser and remainderTokens info saved in the contract
address public remainderPurchaser;
uint256 public remainderAmount;
// external contracts
event MintedTokensFor(address indexed investor, uint256 tokensPurchased);
event TokenRateChanged(uint256 previousRate, uint256 newRate);
function REBCrowdsale
(uint256 _openingTime,
uint256 _closingTime,
REBToken _token,
uint256 _rate,
address _wallet,
address _bountyWallet)
public
FinalizableCrowdsale()
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
{
require(_bountyWallet != address(0));
bountyWallet = _bountyWallet;
require(REBToken(token).paused());
// NOTE: Ensure token ownership is transferred to crowdsale so it able to mint tokens
}
function setRate(uint256 newRate) external onlyOwner {
require(newRate != 0);
TokenRateChanged(rate, newRate);
rate = newRate;
}
function mintTokensFor(address beneficiaryAddress, uint256 amountOfTokens)
public
onlyOwner
{
require(beneficiaryAddress != address(0));
require(token.totalSupply().add(amountOfTokens) <= TOTAL_TOKENS_FOR_CROWDSALE);
_deliverTokens(beneficiaryAddress, amountOfTokens);
MintedTokensFor(beneficiaryAddress, amountOfTokens);
}
function setTeamAndAdvisorAndAirdropAddresses
(address _teamReserve,
address _advisorReserve,
address _airdrop)
public
onlyOwner
{
// only able to be set once
require(teamReserve == address(0x0) && advisorReserve == address(0x0) && airdrop == address(0x0));
// ensure that the addresses as params to the func are not empty
require(_teamReserve != address(0x0) && _advisorReserve != address(0x0) && _airdrop != address(0x0));
teamReserve = _teamReserve;
advisorReserve = _advisorReserve;
airdrop = _airdrop;
}
// overriding TimeCrowdsale#hasClosed to add cap logic
// @return true if crowdsale event has ended
function hasClosed() public view returns (bool) {
if (token.totalSupply() > PUBLIC_CROWDSALE_SOFT_CAP) {
return true;
}
return super.hasClosed();
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount)
internal
isWhitelisted(_beneficiary)
whenNotPaused
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
require(token.totalSupply() < TOTAL_TOKENS_FOR_CROWDSALE);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 tokensAmount = _weiAmount.mul(rate);
// remainder logic
if (token.totalSupply().add(tokensAmount) > TOTAL_TOKENS_FOR_CROWDSALE) {
tokensAmount = TOTAL_TOKENS_FOR_CROWDSALE.sub(token.totalSupply());
uint256 _weiAmountLocalScope = tokensAmount.div(rate);
// save info so as to refund purchaser after crowdsale's end
remainderPurchaser = msg.sender;
remainderAmount = _weiAmount.sub(_weiAmountLocalScope);
if (weiRaised > _weiAmount.add(_weiAmountLocalScope))
weiRaised = weiRaised.sub(_weiAmount.add(_weiAmountLocalScope));
}
return tokensAmount;
}
function finalization() internal {
// This must have been set manually prior to finalize().
require(teamReserve != address(0x0) && advisorReserve != address(0x0) && airdrop != address(0x0));
if (TOTAL_TOKENS_FOR_CROWDSALE > token.totalSupply()) {
uint256 remainingTokens = TOTAL_TOKENS_FOR_CROWDSALE.sub(token.totalSupply());
_deliverTokens(wallet, remainingTokens);
}
// final minting
_deliverTokens(bountyWallet, BOUNTY_SHARE);
_deliverTokens(teamReserve, TEAM_SHARE);
_deliverTokens(advisorReserve, ADVISOR_SHARE);
_deliverTokens(airdrop, AIRDROP_SHARE);
REBToken(token).finishMinting();
REBToken(token).unpause();
super.finalization();
}
}
| 188,611 | 812 |
fedcfacfb78ec4950840cb2bdaa2a0cc5397159adca2618d45152aa4986f410e
| 17,538 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/01/01087Ce1A815a624dd8C257f43aDDDA8ef31441e_Distributor.sol
| 3,878 | 15,340 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable SKI;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ski, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_ski != address(0));
SKI = _ski;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(SKI).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
});
}
}
| 115,514 | 813 |
3b367c50886207f28f95de9c4c44c24d81e81369c45566ff72709fef590c8987
| 28,469 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Reentrancy/Sol/buggy_34.sol
| 6,648 | 22,091 |
pragma solidity 0.4.25;
contract Ownable {
bool not_called_re_ent41 = true;
function bug_re_ent41() public{
require(not_called_re_ent41);
msg.sender.call.value(1 ether)("") ;//Reentrancy bug
revert();
not_called_re_ent41 = false;
}
address public owner;
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 OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
mapping(address => uint) balances_re_ent31;
function withdrawFunds_re_ent31 (uint256 _weiToWithdraw) public {
require(balances_re_ent31[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent31[msg.sender] -= _weiToWithdraw;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
owner = _newOwner;
}
address lastPlayer_re_ent30;
uint jackpot_re_ent30;
function buyTicket_re_ent30() public{
lastPlayer_re_ent30.call.value(jackpot_re_ent30)("");//Reentrancy bug
revert();
lastPlayer_re_ent30 = msg.sender;
jackpot_re_ent30 = 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;
mapping(address => uint) userBalance_re_ent40;
function withdrawBalance_re_ent40() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)=msg.sender.call.value(userBalance_re_ent40[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent40[msg.sender] = 0;
}
mapping (address => transferMapping) private _balances;
mapping(address => uint) redeemableEther_re_ent4;
function deposit_re_ent4() public payable{
uint amount = msg.value;
redeemableEther_re_ent4[msg.sender]+=amount;
}
function claimReward_re_ent4() public {
// ensure there is a reward to give
require(redeemableEther_re_ent4[msg.sender] > 0);
uint transferValue_re_ent4 = redeemableEther_re_ent4[msg.sender];
msg.sender.call.value(transferValue_re_ent4)(""); //bug //Reentrancy bug
redeemableEther_re_ent4[msg.sender] = 0;
}
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => uint) redeemableEther_re_ent39;
function claimReward_re_ent39() public {
// ensure there is a reward to give
require(redeemableEther_re_ent39[msg.sender] > 0);
uint transferValue_re_ent39 = redeemableEther_re_ent39[msg.sender];
msg.sender.call.value(transferValue_re_ent39)(""); //bug //Reentrancy bug
redeemableEther_re_ent39[msg.sender] = 0;
}
uint256 private _totalSupply;
mapping(address => uint) balances_re_ent38;
function withdrawFunds_re_ent38 (uint256 _weiToWithdraw) public {
require(balances_re_ent38[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent38[msg.sender] -= _weiToWithdraw;
}
uint256 public _maxTotalSupply;
address lastPlayer_re_ent37;
uint jackpot_re_ent37;
function buyTicket_re_ent37() public{
lastPlayer_re_ent37.call.value(jackpot_re_ent37)(""); //Reentrancy bug
revert();
lastPlayer_re_ent37 = msg.sender;
jackpot_re_ent37 = address(this).balance;
}
string private _name = "Lollypop";
mapping(address => uint) balances_re_ent36;
function withdraw_balances_re_ent36 () public {
msg.sender.call.value(balances_re_ent36[msg.sender ])(""); //Reentrancy bug
balances_re_ent36[msg.sender] = 0;
}
string private _symbol = "Lolly";
uint256 counter_re_ent35 =0;
function callme_re_ent35() public{
require(counter_re_ent35<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent35 += 1;
}
uint8 private _decimals= 18;
bool not_called_re_ent34 = true;
function bug_re_ent34() public{
require(not_called_re_ent34);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent34 = false;
}
uint256 public maxAgeOfToken = 365 days;
mapping(address => uint) userBalance_re_ent33;
function withdrawBalance_re_ent33() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent33[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent33[msg.sender] = 0;
}
uint256 public minAgeOfToken = 1 days;
mapping(address => uint) redeemableEther_re_ent32;
function claimReward_re_ent32() public {
// ensure there is a reward to give
require(redeemableEther_re_ent32[msg.sender] > 0);
uint transferValue_re_ent32 = redeemableEther_re_ent32[msg.sender];
msg.sender.call.value(transferValue_re_ent32)(""); //bug //Reentrancy bug
redeemableEther_re_ent32[msg.sender] = 0;
}
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;
}
mapping(address => uint) balances_re_ent3;
function deposit_re_ent3() public payable{
uint amount = msg.value;
balances_re_ent3[msg.sender]+=amount;
}
function withdrawFunds_re_ent3 (uint256 _weiToWithdraw) public {
require(balances_re_ent3[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent3[msg.sender] -= _weiToWithdraw;
}
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;
}
mapping(address => uint) balances_re_ent29;
function withdraw_balances_re_ent29 () public {
msg.sender.call.value(balances_re_ent29[msg.sender ])(""); //Reentrancy bug
balances_re_ent29[msg.sender] = 0;
}
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 bonus2 = 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);
}
uint256 counter_re_ent28 =0;
function callme_re_ent28() public{
require(counter_re_ent28<=5);
msg.sender.call.value(10 ether)(""); //Reentrancy bug
revert();
counter_re_ent28 += 1;
}
function name() public view returns (string memory) {
return _name;
}
bool not_called_re_ent27 = true;
function bug_re_ent27() public{
require(not_called_re_ent27);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent27 = false;
}
function symbol() public view returns (string memory) {
return _symbol;
}
mapping(address => uint) userBalance_re_ent26;
function withdrawBalance_re_ent26() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent26[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent26[msg.sender] = 0;
}
function decimals() public view returns (uint8) {
return _decimals;
}
mapping(address => uint) redeemableEther_re_ent25;
function claimReward_re_ent25() public {
// ensure there is a reward to give
require(redeemableEther_re_ent25[msg.sender] > 0);
uint transferValue_re_ent25 = redeemableEther_re_ent25[msg.sender];
msg.sender.call.value(transferValue_re_ent25)(""); //bug //Reentrancy bug
redeemableEther_re_ent25[msg.sender] = 0;
}
modifier onlyLollypopAndOwner {
require(msg.sender == address(this) || msg.sender == owner);
_;
}
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 Transfer(address indexed from, address indexed to, uint256 value);
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 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);
}
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;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
address 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;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account].amount;
}
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;
}
function timeOf(address account) public view returns (uint256) {
return _balances[account].time;
}
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;
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
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;
}
}
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]);
}
}
address 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;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
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 approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
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 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;
}
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 increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
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 decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
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 _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);
}
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 _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);
}
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 account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
address 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,728 | 814 |
6f6d14b10cba2757e3965b0dfb55a4fe4180e6b7b96be335d2f917a8f83d6c29
| 37,683 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/uninitializedLocalVariables/0xA5c16eb6eBD72BC72c70Fca3e4faCf389AD4aBE7_uninitializedLocalStateVariables.sol
| 5,241 | 20,482 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c ; //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) {
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;
}
}
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) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is 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 { }
}
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 {
// 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 IConverter {
function token() external returns (address _share);
function convert(address _input, address _output, uint _inputAmount) external returns (uint _outputAmount);
function convert_rate(address _input, address _output, uint _inputAmount) external view returns (uint _outputAmount);
function convert_stables(uint[3] calldata amounts) external returns (uint _shareAmount); // 0: DAI, 1: USDC, 2: USDT
function get_dy(int128 i, int128 j, uint dx) external view returns (uint);
function exchange(int128 i, int128 j, uint dx, uint min_dy) external returns (uint dy);
function calc_token_amount(uint[3] calldata amounts, bool deposit) external view returns (uint _shareAmount);
function calc_token_amount_withdraw(uint _shares, address _output) external view returns (uint _outputAmount);
}
interface IVaultManager {
function yax() external view returns (address);
function vaults(address) external view returns (bool);
function controllers(address) external view returns (bool);
function strategies(address) external view returns (bool);
function stakingPool() external view returns (address);
function profitSharer() external view returns (address);
function treasuryWallet() external view returns (address);
function performanceReward() external view returns (address);
function stakingPoolShareFee() external view returns (uint);
function gasFee() external view returns (uint);
function insuranceFee() external view returns (uint);
function withdrawalProtectionFee() external view returns (uint);
}
interface IStableSwap3Pool {
function get_virtual_price() external view returns (uint);
function get_dy(int128 i, int128 j, uint dx) external view returns (uint dy);
function exchange(int128 i, int128 j, uint dx, uint min_dy) external;
function add_liquidity(uint[3] calldata amounts, uint min_mint_amount) external;
function remove_liquidity(uint _amount, uint[3] calldata amounts) external;
function remove_liquidity_one_coin(uint _token_amount, int128 i, uint min_amount) external;
function calc_token_amount(uint[3] calldata amounts, bool deposit) external view returns (uint);
function calc_withdraw_one_coin(uint _token_amount, int128 i) external view returns (uint);
}
contract StableSwap3PoolConverter is IConverter {
using SafeMath for uint;
using SafeERC20 for IERC20;
IERC20[3] public tokens; // DAI, USDC, USDT
IERC20 public token3CRV; // 3Crv
address public governance;
IStableSwap3Pool public stableSwap3Pool;
IVaultManager public vaultManager;
constructor (IERC20 _tokenDAI, IERC20 _tokenUSDC, IERC20 _tokenUSDT, IERC20 _token3CRV, IStableSwap3Pool _stableSwap3Pool, IVaultManager _vaultManager) public {
tokens[0] = _tokenDAI;
tokens[1] = _tokenUSDC;
tokens[2] = _tokenUSDT;
token3CRV = _token3CRV;
stableSwap3Pool = _stableSwap3Pool;
tokens[0].safeApprove(address(stableSwap3Pool), uint(-1));
tokens[1].safeApprove(address(stableSwap3Pool), uint(-1));
tokens[2].safeApprove(address(stableSwap3Pool), uint(-1));
token3CRV.safeApprove(address(stableSwap3Pool), uint(-1));
vaultManager = _vaultManager;
governance = msg.sender;
}
function setGovernance(address _governance) public {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setStableSwap3Pool(IStableSwap3Pool _stableSwap3Pool) public {
require(msg.sender == governance, "!governance");
stableSwap3Pool = _stableSwap3Pool;
tokens[0].safeApprove(address(stableSwap3Pool), uint(-1));
tokens[1].safeApprove(address(stableSwap3Pool), uint(-1));
tokens[2].safeApprove(address(stableSwap3Pool), uint(-1));
token3CRV.safeApprove(address(stableSwap3Pool), uint(-1));
}
function setVaultManager(IVaultManager _vaultManager) public {
require(msg.sender == governance, "!governance");
vaultManager = _vaultManager;
}
function approveForSpender(IERC20 _token, address _spender, uint _amount) external {
require(msg.sender == governance, "!governance");
_token.safeApprove(_spender, _amount);
}
function token() external override returns (address _share) {
_share = address(token3CRV);
}
function convert(address _input, address _output, uint _inputAmount) external override returns (uint _outputAmount) {
require(msg.sender == governance || vaultManager.vaults(msg.sender), "!(governance||vault)");
if (_output == address(token3CRV)) { // convert to 3CRV
uint[3] memory amounts;
for (uint8 i ; i < 3; i++) { //inject UNINIT LOCAL/STATE VAR
if (_input == address(tokens[i])) {
amounts[i] = _inputAmount;
uint _before ; //inject UNINIT LOCAL/STATE VAR
stableSwap3Pool.add_liquidity(amounts, 1);
uint _after ; //inject UNINIT LOCAL/STATE VAR
_outputAmount = _after.sub(_before);
token3CRV.safeTransfer(msg.sender, _outputAmount);
return _outputAmount;
}
}
} else if (_input == address(token3CRV)) { // convert from 3CRV
for (uint8 i ; i < 3; i++) { //inject UNINIT LOCAL/STATE VAR
if (_output == address(tokens[i])) {
uint _before ; //inject UNINIT LOCAL/STATE VAR
stableSwap3Pool.remove_liquidity_one_coin(_inputAmount, i, 1);
uint _after ; //inject UNINIT LOCAL/STATE VAR
_outputAmount = _after.sub(_before);
tokens[i].safeTransfer(msg.sender, _outputAmount);
return _outputAmount;
}
}
}
return 0;
}
function convert_rate(address _input, address _output, uint _inputAmount) external override view returns (uint _outputAmount) {
if (_output == address(token3CRV)) { // convert to 3CRV
uint[3] memory amounts;
for (uint8 i ; i < 3; i++) { //inject UNINIT LOCAL/STATE VAR
if (_input == address(tokens[i])) {
amounts[i] = _inputAmount;
return stableSwap3Pool.calc_token_amount(amounts, true);
}
}
} else if (_input == address(token3CRV)) { // convert from 3CRV
for (uint8 i ; i < 3; i++) { //inject UNINIT LOCAL/STATE VAR
if (_output == address(tokens[i])) {
return stableSwap3Pool.calc_withdraw_one_coin(_inputAmount, i);
}
}
}
return 0;
}
// 0: DAI, 1: USDC, 2: USDT
function convert_stables(uint[3] calldata amounts) external override returns (uint _shareAmount) {
require(msg.sender == governance || vaultManager.vaults(msg.sender), "!(governance||vault)");
uint _before ; //inject UNINIT LOCAL/STATE VAR
stableSwap3Pool.add_liquidity(amounts, 1);
uint _after ; //inject UNINIT LOCAL/STATE VAR
_shareAmount = _after.sub(_before);
token3CRV.safeTransfer(msg.sender, _shareAmount);
}
function get_dy(int128 i, int128 j, uint dx) external override view returns (uint) {
return stableSwap3Pool.get_dy(i, j, dx);
}
function exchange(int128 i, int128 j, uint dx, uint min_dy) external override returns (uint dy) {
require(msg.sender == governance || vaultManager.vaults(msg.sender), "!(governance||vault)");
IERC20 _output ; //inject UNINIT LOCAL/STATE VAR
uint _before ; //inject UNINIT LOCAL/STATE VAR
stableSwap3Pool.exchange(i, j, dx, min_dy);
uint _after ; //inject UNINIT LOCAL/STATE VAR
dy = _after.sub(_before);
_output.safeTransfer(msg.sender, dy);
}
function calc_token_amount(uint[3] calldata amounts, bool deposit) external override view returns (uint _shareAmount) {
_shareAmount = stableSwap3Pool.calc_token_amount(amounts, deposit);
}
function calc_token_amount_withdraw(uint _shares, address _output) external override view returns (uint) {
for (uint8 i ; i < 3; i++) { //inject UNINIT LOCAL/STATE VAR
if (_output == address(tokens[i])) {
return stableSwap3Pool.calc_withdraw_one_coin(_shares, i);
}
}
return 0;
}
function governanceRecoverUnsupported(IERC20 _token, uint _amount, address _to) external {
require(msg.sender == governance, "!governance");
_token.transfer(_to, _amount);
}
}
| 279,440 | 815 |
81b39c74dea9b5b7a7ec4d949df60190140eb334baba48297b2b794e658626d4
| 25,272 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/f2/F2A862986a20Ab4277269A84d066feC3Fc8A8681_Noonercoin.sol
| 6,314 | 24,396 |
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
using SafeMath for uint256;
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occurenceOfRandomNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 public totalCycleLeft = 19;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
int private count = 0;
uint256 previousCyclesTotalTokens = 0;
uint256 previousCyclesTotalWei = 0;
uint256 indexs = 1;
uint256[] randomVariableArray;
uint256[] previousCyclesBalance;
uint256[] previousCyclesWeiBalance;
uint256 public weiAmountAdded = 0;
uint256 public weiAmountAddedAtBurn = 0;
uint256 signmaValueWei = 0;
uint256 currentMintingRateTotalTokens = 0;
uint256 totalMintedTokens = 0;
uint256 weiToBurned = 0;
uint256 totalWeiInAdminAcc = 0;
uint256[] previousSigmaValues;
uint256[] previousBurnValues;
bool stopTheMinting = false;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
lastMintingTime = startTime;
noonercoin[adminAddress] = _fundersAmount;
}
function incrementCounter() public {
count += 1;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add, uint256 currentTime) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
//burn the tokens before minting
if(isNewCycleStart) {
uint256 randomValue = _randomValue;
if(randomValue == 150){
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(0);
previousBurnValues.push(0);
}
}
else {
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(0);
previousBurnValues.push(0);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
if(stopTheMinting) {
return false;
}
else {
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
//condition to call a popRandomVariable
uint256 nowTime = now;
uint256 totalOccurences = getTotalPresentOcuurences();
if(totalOccurences != 120) {
if(nowTime-weekStartTime >= 720){
popRandomVariable();
weekStartTime=now;
}
}
//adding the minting tokens into the admin account
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = currentTime;
//2nd check for popRandomVaribale
uint256 totalPicks = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
uint256 diff = 0;
uint256 estimatePicks = 0;
uint256 picks = 0;
if(totalPicks != 120 && lastMintingTime != 0) {
diff = lastMintingTime - startTime;
if(diff > _frequency) {
estimatePicks = (diff-_frequency)/720;
if(totalPicks >= estimatePicks){
picks = 0;
}
else {
picks = estimatePicks - totalPicks;
for(uint256 i = 0; i < picks; i++){
popRandomVariable();
}
}
}
}
//changing the mintingrate with above condition
uint256 timeDiff = lastMintingTime - startTime;
if(timeDiff >= _cycleTime){
uint256 tokenWei = 720 * mintingRateNoonerWei;
uint256 tokens = 0;
if(totalCycleLeft != 19){
tokens = tokenWei/10**18 + previousCyclesTotalTokens + weiAmountAdded + weiAmountAddedAtBurn + 720 * mintingRateNoonerCoin;
}
if(totalCycleLeft == 19){
tokens = _fundersAmount + 720 * mintingRateNoonerCoin;
}
if(noonercoin[adminAddress] != tokens) {
noonercoin[adminAddress] = tokens;
}
if(noonerwei[adminAddress] != tokenWei) {
noonerwei[adminAddress] = tokenWei;
}
//wei amount of >.5 to be added in adminAccount
if(noonerwei[adminAddress] >= (10**18/2)) {
noonercoin[adminAddress] += 1;
weiAmountAdded += 1;
}
if(totalCycleLeft == 0) {
stopTheMinting = true;
}
else {
totalCycleLeft = totalCycleLeft - 1;
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
}
}
return true;
}
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occurenceOfRandomNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
if(occurenceOfRandomNumber[randomNumber]<24){
occurenceOfRandomNumber[randomNumber] = occurenceOfRandomNumber[randomNumber]+1;
}
//2nd time calling randomNumber from randomVariablePicker
randomNumber = randomVariablePicker();
//2nd time occurenceOfRandomNumber >= 24
if(occurenceOfRandomNumber[randomNumber] >= 24) {
if(count < 4) {
incrementCounter();
uint256 _index;
//remove variable
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerValue(flag*720, 150**index, index);//720
uint256 intDecimalValue = getDecimalValue(flag*720, 150**index, index);//720
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 adminBalance = noonercoin[adminAddress];
uint256 iterationsInOneCycle = _cycleTime/_frequency;//720
currentMintingRateTotalTokens = iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
totalMintedTokens = (adminBalance-_fundersAmount - weiAmountAdded)*10**18 + noonerwei[adminAddress] + totalWeiBurned; //before adding totalWeiBurned.
weiToBurned = _totalSupply*10**18 - signmaValueWei - totalMintedTokens - currentMintingRateTotalTokens - totalWeiBurned;
totalWeiInAdminAcc = (adminBalance-_fundersAmount - weiAmountAdded) * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc <= weiToBurned) {
return false;
}
uint256 remainingWei;
if(totalWeiInAdminAcc > weiToBurned) {
remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = _fundersAmount + weiAmountAdded + (remainingWei/10**18);
uint256 weiAddedInAdminAccount = remainingWei - (noonercoin[adminAddress] - _fundersAmount - weiAmountAdded) * 10**18;
//add +1 token to adminAccount when remain wei is >.5
if(weiAddedInAdminAccount >= (10**18/2)) {
noonercoin[adminAddress] += 1;
weiToBurned = (weiToBurned/10**18)* 10**18;
weiAmountAddedAtBurn += 1;
}
noonerwei[adminAddress] = 0;
totalWeiBurned = totalWeiBurned + weiToBurned;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[adminAddress];
previousCyclesTotalWei = remainingWei - (noonercoin[adminAddress] - _fundersAmount - weiAmountAdded - weiAmountAddedAtBurn) * 10**18;
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(signmaValueWei);
previousBurnValues.push(weiToBurned);
}
return true;
}
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) public view returns (uint256){
return noonerwei[add];
}
function getIntegerValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
if(isNewCycleStart){
uint256 randomValue = _randomValue;
if(randomValue == 150){
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(0);
previousBurnValues.push(0);
}
}
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousBurnValues.push(0);
previousSigmaValues.push(0);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
if(stopTheMinting) {
return false;
}
else {
uint256 weiAfterMint = missedWei;
noonercoin[add] = noonercoin[add] + missedToken;
noonerwei[add] = weiAfterMint;
return true;
}
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
//wei amount of >.5 to be added in adminAccount
if(noonerwei[adminAddress] >= (10**18/2)) {
noonercoin[adminAddress] += 1;
weiAmountAdded += 1;
}
if(stopTheMinting) {
return false;
}
else {
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
return true;
}
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference = 0;
if(lastMintingTime != 0) {
lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
}
return lastMintingTimeAndStartTimeDifference;
}
function checkMissingTokens(address add) public view returns (uint256, uint256, uint256, uint256) {
uint256 adminBalance = 0;//noonercoin[add]; //admin bal
uint256 adminBalanceinWei = 0;//noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0,0, 0, totalCycleLeft);
}
if (lastMintingTime != 0) {
uint256 estimatedMintedToken = 0;
uint256 estimatedMintedTokenWei = 0;
uint256 timeDifference = lastMintingTime - startTime;
uint256 valueForEach = timeDifference.div(_frequency);
if(totalCycleLeft != 19) {
adminBalance = noonercoin[add] - weiAmountAdded - weiAmountAddedAtBurn; //admin bal
adminBalanceinWei = noonerwei[add]; //admin bal wei
estimatedMintedToken = (previousCyclesTotalTokens - weiAmountAdded - weiAmountAddedAtBurn) + valueForEach * mintingRateNoonerCoin;
estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;
}
if(totalCycleLeft == 19) {
adminBalance = noonercoin[add]; //admin bal
adminBalanceinWei = noonerwei[add]; //admin bal wei
estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;
}
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedToken += temp;
uint256 weiVariance = estimatedMintedTokenWei - (temp * 10**18);
uint256 checkDifference = 0;
if(estimatedMintedToken != adminBalance) {
if(adminBalance >= estimatedMintedToken) {
checkDifference = 0;
} else {
checkDifference = estimatedMintedToken - adminBalance;
}
}
if(weiVariance == adminBalanceinWei) {
weiVariance = 0;
}
return (checkDifference, weiVariance, weekStartTime, totalCycleLeft);
}
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory) {
return (_randomValue, __remainingRandomVariable);
}
function getOccurenceOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occurenceOfRandomNumber[__randomVariable[0]],occurenceOfRandomNumber[__randomVariable[1]],occurenceOfRandomNumber[__randomVariable[2]],occurenceOfRandomNumber[__randomVariable[3]], occurenceOfRandomNumber[__randomVariable[4]]);
}
function getOccurenceOfPreferredRandomNumber(uint256 number) public view returns(uint256){
return occurenceOfRandomNumber[number];
}
function getTotalPresentOcuurences() public view returns(uint256){
uint256 total = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
return total;
}
function getRandomVariablesArray() public view returns(uint256[] memory) {
return(randomVariableArray);
}
function previousCyclesBalances() public view returns(uint256[] memory) {
return(previousCyclesBalance);
}
function getLastMintingRateWei() public view returns(uint256) {
return(mintingRateNoonerWei);
}
function getBurnValues(address add) public view returns(uint256, uint256, uint256, uint256, uint256, uint256) {
return(signmaValueWei, currentMintingRateTotalTokens, totalMintedTokens, weiToBurned, totalWeiInAdminAcc, weiAmountAdded);
}
function previousCyclesBurn() public view returns(uint256[] memory) {
return(previousBurnValues);
}
function previousCyclesSigmaValue() public view returns(uint256[] memory) {
return(previousSigmaValues);
}
}
| 113,573 | 816 |
9b36549ac0d7a04f8a5a5305a978c1de9aa3b232ce852c9f2249865ef7c24782
| 19,481 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTEYKhLtwJFC2GcM27R4t3NRAxVaFo8xh9_Tronqual.sol
| 4,542 | 17,258 |
//SourceUnit: Tronqual.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract Tronqual {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 286,765 | 817 |
79c90f59874b97b37612b24724aaea03f3c0aae3f44ae9803c0d3abd46ca5f7a
| 27,532 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/44/44bdc3a48677e4814e338da0361c1fffe9037d18_gOHM.sol
| 4,762 | 18,843 |
// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.7.5;
// TODO(zx): Replace all instances of SafeMath with OZ implementation
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;
}
// Only used in the BondingCalculator.sol
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;
}
}
}
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);
}
// TODO(zx): replace with OZ implementation.
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");
}
// require(address(this).balance >= value, "Address: insufficient balance for call");
// return _functionCallWithValue(target, data, value, errorMessage);
// }
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);
}
}
interface IsOHM is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() 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);
function toG(uint amount) external view returns (uint);
function fromG(uint amount) external view returns (uint);
function changeDebt(uint256 amount,
address debtor,
bool add) external;
function debtBalances(address _address) external view returns (uint256);
}
interface IgOHM is IERC20 {
function mint(address _to, uint256 _amount) external;
function burn(address _from, uint256 _amount) external;
function index() external view returns (uint256);
function balanceFrom(uint256 _amount) external view returns (uint256);
function balanceTo(uint256 _amount) external view returns (uint256);
function migrate(address _staking, address _sOHM) external;
}
abstract contract ERC20 is IERC20 {
using SafeMath for uint256;
// TODO comment actual hash value.
bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256("ERC20Token");
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal immutable _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
contract gOHM is IgOHM, ERC20 {
using Address for address;
using SafeMath for uint256;
modifier onlyApproved() {
require(msg.sender == approved, "Only approved");
_;
}
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint256 fromBlock;
uint256 votes;
}
IsOHM public sOHM;
address public approved; // minter
bool public migrated;
mapping(address => mapping(uint256 => Checkpoint)) public checkpoints;
mapping(address => uint256) public numCheckpoints;
mapping(address => address) public delegates;
constructor(address _migrator, address _sOHM)
ERC20("Governance OHM", "gOHM", 18)
{
require(_migrator != address(0), "Zero address: Migrator");
approved = _migrator;
require(_sOHM != address(0), "Zero address: sOHM");
sOHM = IsOHM(_sOHM);
}
function migrate(address _staking, address _sOHM) external override onlyApproved {
require(!migrated, "Migrated");
migrated = true;
require(_staking != approved, "Invalid argument");
require(_staking != address(0), "Zero address found");
approved = _staking;
require(_sOHM != address(0), "Zero address found");
sOHM = IsOHM(_sOHM);
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function mint(address _to, uint256 _amount) external override onlyApproved {
_mint(_to, _amount);
}
function burn(address _from, uint256 _amount) external override onlyApproved {
_burn(_from, _amount);
}
function index() public view override returns (uint256) {
return sOHM.index();
}
function balanceFrom(uint256 _amount) public view override returns (uint256) {
return _amount.mul(index()).div(10**decimals());
}
function balanceTo(uint256 _amount) public view override returns (uint256) {
return _amount.mul(10**decimals()).div(index());
}
function getCurrentVotes(address account) external view returns (uint256) {
uint256 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint256 blockNumber) external view returns (uint256) {
require(blockNumber < block.number, "gOHM::getPriorVotes: not yet determined");
uint256 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;
}
uint256 lower = 0;
uint256 upper = nCheckpoints - 1;
while (upper > lower) {
uint256 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 = _balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep,
address dstRep,
uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint256 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)) {
uint256 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,
uint256 nCheckpoints,
uint256 oldVotes,
uint256 newVotes) internal {
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == block.number) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(block.number, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal override {
_moveDelegates(delegates[from], delegates[to], amount);
}
}
| 323,537 | 818 |
ecdf357882914a1eb83aa7f9032fc914512aec04f6c2d064ee0d7c878d5eeffa
| 21,655 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x6e9f056176b7997a98b9919bfb6642d4ea92a1ba.sol
| 5,999 | 20,943 |
pragma solidity 0.4.25;
library SafeMath16 {
function mul(uint16 a, uint16 b) internal pure returns (uint16) {
if (a == 0) {
return 0;
}
uint16 c = a * b;
assert(c / a == b);
return c;
}
function div(uint16 a, uint16 b) internal pure returns (uint16) {
return a / b;
}
function sub(uint16 a, uint16 b) internal pure returns (uint16) {
assert(b <= a);
return a - b;
}
function add(uint16 a, uint16 b) internal pure returns (uint16) {
uint16 c = a + b;
assert(c >= a);
return c;
}
function pow(uint16 a, uint16 b) internal pure returns (uint16) {
if (a == 0) return 0;
if (b == 0) return 1;
uint16 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
library SafeMath32 {
function mul(uint32 a, uint32 b) internal pure returns (uint32) {
if (a == 0) {
return 0;
}
uint32 c = a * b;
assert(c / a == b);
return c;
}
function div(uint32 a, uint32 b) internal pure returns (uint32) {
return a / b;
}
function sub(uint32 a, uint32 b) internal pure returns (uint32) {
assert(b <= a);
return a - b;
}
function add(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
assert(c >= a);
return c;
}
function pow(uint32 a, uint32 b) internal pure returns (uint32) {
if (a == 0) return 0;
if (b == 0) return 1;
uint32 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
library SafeMath256 {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function pow(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
if (b == 0) return 1;
uint256 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
library SafeConvert {
function toUint8(uint256 _value) internal pure returns (uint8) {
assert(_value <= 255);
return uint8(_value);
}
function toUint16(uint256 _value) internal pure returns (uint16) {
assert(_value <= 2**16 - 1);
return uint16(_value);
}
function toUint32(uint256 _value) internal pure returns (uint32) {
assert(_value <= 2**32 - 1);
return uint32(_value);
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function _validateAddress(address _addr) internal pure {
require(_addr != address(0), "invalid address");
}
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "not a contract owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_validateAddress(newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Controllable is Ownable {
mapping(address => bool) controllers;
modifier onlyController {
require(_isController(msg.sender), "no controller rights");
_;
}
function _isController(address _controller) internal view returns (bool) {
return controllers[_controller];
}
function _setControllers(address[] _controllers) internal {
for (uint256 i = 0; i < _controllers.length; i++) {
_validateAddress(_controllers[i]);
controllers[_controllers[i]] = true;
}
}
}
contract Upgradable is Controllable {
address[] internalDependencies;
address[] externalDependencies;
function getInternalDependencies() public view returns(address[]) {
return internalDependencies;
}
function getExternalDependencies() public view returns(address[]) {
return externalDependencies;
}
function setInternalDependencies(address[] _newDependencies) public onlyOwner {
for (uint256 i = 0; i < _newDependencies.length; i++) {
_validateAddress(_newDependencies[i]);
}
internalDependencies = _newDependencies;
}
function setExternalDependencies(address[] _newDependencies) public onlyOwner {
externalDependencies = _newDependencies;
_setControllers(_newDependencies);
}
}
contract ERC721Token {
function ownerOf(uint256 _tokenId) public view returns (address _owner);
}
contract DragonCoreHelper {
function calculateCurrent(uint256, uint32, uint32) external pure returns (uint32, uint8) {}
function calculateHealthAndMana(uint32, uint32, uint32, uint32) external pure returns (uint32, uint32) {}
function getSpecialBattleSkillDragonType(uint8[11], uint256) external pure returns (uint8) {}
function calculateSpecialPeacefulSkill(uint8, uint32[5], uint32[5]) external pure returns (uint32, uint32) {}
function calculateCoolness(uint256[4]) external pure returns (uint32) {}
function calculateSkills(uint256[4]) external pure returns (uint32, uint32, uint32, uint32, uint32) {}
function calculateExperience(uint8, uint256, uint16, uint256) external pure returns (uint8, uint256, uint16) {}
function checkAndConvertName(string) external pure returns(bytes32, bytes32) {}
function upgradeGenes(uint256[4], uint16[10], uint16) external pure returns (uint256[4], uint16) {}
}
contract DragonParams {
function dnaPoints(uint8) external pure returns (uint16) {}
}
contract DragonModel {
struct HealthAndMana {
uint256 timestamp;
uint32 remainingHealth;
uint32 remainingMana;
uint32 maxHealth;
uint32 maxMana;
}
struct Level {
uint8 level;
uint8 experience;
uint16 dnaPoints;
}
struct Battles {
uint16 wins;
uint16 defeats;
}
struct Skills {
uint32 attack;
uint32 defense;
uint32 stamina;
uint32 speed;
uint32 intelligence;
}
}
contract DragonStorage is DragonModel, ERC721Token {
mapping (bytes32 => bool) public existingNames;
mapping (uint256 => bytes32) public names;
mapping (uint256 => HealthAndMana) public healthAndMana;
mapping (uint256 => Battles) public battles;
mapping (uint256 => Skills) public skills;
mapping (uint256 => Level) public levels;
mapping (uint256 => uint8) public specialPeacefulSkills;
mapping (uint256 => mapping (uint8 => uint32)) public buffs;
function getGenome(uint256) external pure returns (uint256[4]) {}
function push(address, uint16, uint256[4], uint256[2], uint8[11]) public returns (uint256) {}
function setName(uint256, bytes32, bytes32) external {}
function setTactics(uint256, uint8, uint8) external {}
function setWins(uint256, uint16) external {}
function setDefeats(uint256, uint16) external {}
function setMaxHealthAndMana(uint256, uint32, uint32) external {}
function setRemainingHealthAndMana(uint256, uint32, uint32) external {}
function resetHealthAndManaTimestamp(uint256) external {}
function setSkills(uint256, uint32, uint32, uint32, uint32, uint32) external {}
function setLevel(uint256, uint8, uint8, uint16) external {}
function setCoolness(uint256, uint32) external {}
function setGenome(uint256, uint256[4]) external {}
function setSpecialAttack(uint256, uint8) external {}
function setSpecialDefense(uint256, uint8) external {}
function setSpecialPeacefulSkill(uint256, uint8) external {}
function setBuff(uint256, uint8, uint32) external {}
}
contract Random {
function random(uint256) external pure returns (uint256) {}
function randomOfBlock(uint256, uint256) external pure returns (uint256) {}
}
//////////////CONTRACT//////////////
contract DragonBase is Upgradable {
using SafeMath32 for uint32;
using SafeMath256 for uint256;
using SafeConvert for uint32;
using SafeConvert for uint256;
DragonStorage _storage_;
DragonParams params;
DragonCoreHelper helper;
Random random;
function _identifySpecialBattleSkills(uint256 _id,
uint8[11] _dragonTypes) internal {
uint256 _randomSeed = random.random(10000); // generate 4-digit number in range [0, 9999]
uint256 _attackRandom = _randomSeed % 100; // 2-digit number (last 2 digits)
uint256 _defenseRandom = _randomSeed / 100; // 2-digit number (first 2 digits)
// we have 100 variations of random number but genes only 40, so we calculate random [0..39]
_attackRandom = _attackRandom.mul(4).div(10);
_defenseRandom = _defenseRandom.mul(4).div(10);
uint8 _attackType = helper.getSpecialBattleSkillDragonType(_dragonTypes, _attackRandom);
uint8 _defenseType = helper.getSpecialBattleSkillDragonType(_dragonTypes, _defenseRandom);
_storage_.setSpecialAttack(_id, _attackType);
_storage_.setSpecialDefense(_id, _defenseType);
}
function _setSkillsAndHealthAndMana(uint256 _id, uint256[4] _genome, uint8[11] _dragonTypes) internal {
(uint32 _attack,
uint32 _defense,
uint32 _stamina,
uint32 _speed,
uint32 _intelligence) = helper.calculateSkills(_genome);
_storage_.setSkills(_id, _attack, _defense, _stamina, _speed, _intelligence);
_identifySpecialBattleSkills(_id, _dragonTypes);
(uint32 _health,
uint32 _mana) = helper.calculateHealthAndMana(_stamina, _intelligence, 0, 0);
_storage_.setMaxHealthAndMana(_id, _health, _mana);
}
function setInternalDependencies(address[] _newDependencies) public onlyOwner {
super.setInternalDependencies(_newDependencies);
_storage_ = DragonStorage(_newDependencies[0]);
params = DragonParams(_newDependencies[1]);
helper = DragonCoreHelper(_newDependencies[2]);
random = Random(_newDependencies[3]);
}
}
contract DragonCore is DragonBase {
using SafeMath16 for uint16;
uint8 constant MAX_LEVEL = 10; // max dragon level
uint8 constant MAX_TACTICS_PERCENTAGE = 80;
uint8 constant MIN_TACTICS_PERCENTAGE = 20;
uint8 constant MAX_GENE_LVL = 99; // max dragon gene level
uint8 constant NUMBER_OF_SPECIAL_PEACEFUL_SKILL_CLASSES = 8; // first is empty skill
// does dragon have enough DNA points for breeding?
function isBreedingAllowed(uint8 _level, uint16 _dnaPoints) public view returns (bool) {
return _level > 0 && _dnaPoints >= params.dnaPoints(_level);
}
function _checkIfEnoughPoints(bool _isEnough) internal pure {
require(_isEnough, "not enough points");
}
function _validateSpecialPeacefulSkillClass(uint8 _class) internal pure {
require(_class > 0 && _class < NUMBER_OF_SPECIAL_PEACEFUL_SKILL_CLASSES, "wrong class of special peaceful skill");
}
function _checkIfSpecialPeacefulSkillAvailable(bool _isAvailable) internal pure {
require(_isAvailable, "special peaceful skill selection is not available");
}
function _getBuff(uint256 _id, uint8 _class) internal view returns (uint32) {
return _storage_.buffs(_id, _class);
}
function _getAllBuffs(uint256 _id) internal view returns (uint32[5]) {
return [
_getBuff(_id, 1),
_getBuff(_id, 2),
_getBuff(_id, 3),
_getBuff(_id, 4),
_getBuff(_id, 5)
];
}
// GETTERS
function calculateMaxHealthAndManaWithBuffs(uint256 _id) public view returns (uint32 maxHealth,
uint32 maxMana) {
(, , uint32 _stamina, , uint32 _intelligence) = _storage_.skills(_id);
(maxHealth,
maxMana) = helper.calculateHealthAndMana(_stamina,
_intelligence,
_getBuff(_id, 3), // stamina buff
_getBuff(_id, 5) // intelligence buff);
}
function getCurrentHealthAndMana(uint256 _id) public view returns (uint32 health,
uint32 mana,
uint8 healthPercentage,
uint8 manaPercentage) {
(uint256 _timestamp,
uint32 _remainingHealth,
uint32 _remainingMana,
uint32 _maxHealth,
uint32 _maxMana) = _storage_.healthAndMana(_id);
(_maxHealth, _maxMana) = calculateMaxHealthAndManaWithBuffs(_id);
uint256 _pastTime = now.sub(_timestamp); // solium-disable-line security/no-block-members
(health, healthPercentage) = helper.calculateCurrent(_pastTime, _maxHealth, _remainingHealth);
(mana, manaPercentage) = helper.calculateCurrent(_pastTime, _maxMana, _remainingMana);
}
// SETTERS
function setRemainingHealthAndMana(uint256 _id,
uint32 _remainingHealth,
uint32 _remainingMana) external onlyController {
_storage_.setRemainingHealthAndMana(_id, _remainingHealth, _remainingMana);
}
function increaseExperience(uint256 _id, uint256 _factor) external onlyController {
(uint8 _level,
uint256 _experience,
uint16 _dnaPoints) = _storage_.levels(_id);
uint8 _currentLevel = _level;
if (_level < MAX_LEVEL) {
(_level, _experience, _dnaPoints) = helper.calculateExperience(_level, _experience, _dnaPoints, _factor);
if (_level > _currentLevel) {
// restore hp and mana if level up
_storage_.resetHealthAndManaTimestamp(_id);
}
if (_level == MAX_LEVEL) {
_experience = 0;
}
_storage_.setLevel(_id, _level, _experience.toUint8(), _dnaPoints);
}
}
function payDNAPointsForBreeding(uint256 _id) external onlyController {
(uint8 _level,
uint8 _experience,
uint16 _dnaPoints) = _storage_.levels(_id);
_checkIfEnoughPoints(isBreedingAllowed(_level, _dnaPoints));
_dnaPoints = _dnaPoints.sub(params.dnaPoints(_level));
_storage_.setLevel(_id, _level, _experience, _dnaPoints);
}
function upgradeGenes(uint256 _id, uint16[10] _dnaPoints) external onlyController {
(uint8 _level,
uint8 _experience,
uint16 _availableDNAPoints) = _storage_.levels(_id);
uint16 _sum;
uint256[4] memory _newComposedGenome;
(_newComposedGenome,
_sum) = helper.upgradeGenes(_storage_.getGenome(_id),
_dnaPoints,
_availableDNAPoints);
require(_sum > 0, "DNA points were not used");
_availableDNAPoints = _availableDNAPoints.sub(_sum);
// save data
_storage_.setLevel(_id, _level, _experience, _availableDNAPoints);
_storage_.setGenome(_id, _newComposedGenome);
_storage_.setCoolness(_id, helper.calculateCoolness(_newComposedGenome));
// recalculate skills
_saveSkills(_id, _newComposedGenome);
}
function _saveSkills(uint256 _id, uint256[4] _genome) internal {
(uint32 _attack,
uint32 _defense,
uint32 _stamina,
uint32 _speed,
uint32 _intelligence) = helper.calculateSkills(_genome);
(uint32 _health,
uint32 _mana) = helper.calculateHealthAndMana(_stamina, _intelligence, 0, 0); // without buffs
_storage_.setMaxHealthAndMana(_id, _health, _mana);
_storage_.setSkills(_id, _attack, _defense, _stamina, _speed, _intelligence);
}
function increaseWins(uint256 _id) external onlyController {
(uint16 _wins,) = _storage_.battles(_id);
_storage_.setWins(_id, _wins.add(1));
}
function increaseDefeats(uint256 _id) external onlyController {
(, uint16 _defeats) = _storage_.battles(_id);
_storage_.setDefeats(_id, _defeats.add(1));
}
function setTactics(uint256 _id, uint8 _melee, uint8 _attack) external onlyController {
require(_melee >= MIN_TACTICS_PERCENTAGE &&
_melee <= MAX_TACTICS_PERCENTAGE &&
_attack >= MIN_TACTICS_PERCENTAGE &&
_attack <= MAX_TACTICS_PERCENTAGE,
"tactics value must be between 20 and 80");
_storage_.setTactics(_id, _melee, _attack);
}
function calculateSpecialPeacefulSkill(uint256 _id) public view returns (uint8 class,
uint32 cost,
uint32 effect) {
class = _storage_.specialPeacefulSkills(_id);
if (class == 0) return;
(uint32 _attack,
uint32 _defense,
uint32 _stamina,
uint32 _speed,
uint32 _intelligence) = _storage_.skills(_id);
(cost,
effect) = helper.calculateSpecialPeacefulSkill(class,
[_attack, _defense, _stamina, _speed, _intelligence],
_getAllBuffs(_id));
}
function setSpecialPeacefulSkill(uint256 _id, uint8 _class) external onlyController {
(uint8 _level, ,) = _storage_.levels(_id);
uint8 _currentClass = _storage_.specialPeacefulSkills(_id);
_checkIfSpecialPeacefulSkillAvailable(_level == MAX_LEVEL);
_validateSpecialPeacefulSkillClass(_class);
_checkIfSpecialPeacefulSkillAvailable(_currentClass == 0);
_storage_.setSpecialPeacefulSkill(_id, _class);
}
function _getBuffIndexBySpecialPeacefulSkillClass(uint8 _class) internal pure returns (uint8) {
uint8[8] memory _buffsIndexes = [0, 1, 2, 3, 4, 5, 3, 5]; // 0 item - no such class
return _buffsIndexes[_class];
}
// _id - dragon, which will use the skill
// _target - dragon, on which the skill will be used
// _sender - owner of the first dragon
function useSpecialPeacefulSkill(address _sender, uint256 _id, uint256 _target) external onlyController {
(uint8 _class,
uint32 _cost,
uint32 _effect) = calculateSpecialPeacefulSkill(_id);
(uint32 _health,
uint32 _mana, ,) = getCurrentHealthAndMana(_id);
_validateSpecialPeacefulSkillClass(_class);
// enough mana
_checkIfEnoughPoints(_mana >= _cost);
// subtract cost of special peaceful skill
_storage_.setRemainingHealthAndMana(_id, _health, _mana.sub(_cost));
// reset intelligence buff of the first dragon
_storage_.setBuff(_id, 5, 0);
// reset active skill buff of the first dragon
uint8 _buffIndexOfActiveSkill = _getBuffIndexBySpecialPeacefulSkillClass(_class);
_storage_.setBuff(_id, _buffIndexOfActiveSkill, 0);
if (_class == 6 || _class == 7) { // health/mana restoration
(uint32 _targetHealth,
uint32 _targetMana, ,) = getCurrentHealthAndMana(_target);
if (_class == 6) _targetHealth = _targetHealth.add(_effect); // restore health
if (_class == 7) _targetMana = _targetMana.add(_effect); // restore mana
// save restored health/mana
_storage_.setRemainingHealthAndMana(_target,
_targetHealth,
_targetMana);
} else { // another special peaceful skills
if (_storage_.ownerOf(_target) != _sender) { // to prevert lower effect buffing
require(_getBuff(_target, _class) < _effect, "you can't buff alien dragon by lower effect");
}
_storage_.setBuff(_target, _class, _effect);
}
}
function setBuff(uint256 _id, uint8 _class, uint32 _effect) external onlyController {
_storage_.setBuff(_id, _class, _effect);
}
function createDragon(address _sender,
uint16 _generation,
uint256[2] _parents,
uint256[4] _genome,
uint8[11] _dragonTypes) external onlyController returns (uint256 newDragonId) {
newDragonId = _storage_.push(_sender, _generation, _genome, _parents, _dragonTypes);
uint32 _coolness = helper.calculateCoolness(_genome);
_storage_.setCoolness(newDragonId, _coolness);
_storage_.setTactics(newDragonId, 50, 50);
_setSkillsAndHealthAndMana(newDragonId, _genome, _dragonTypes);
}
function setName(uint256 _id,
string _name) external onlyController returns (bytes32) {
(bytes32 _initial, // initial name that converted to bytes32
bytes32 _lowercase // name to lowercase) = helper.checkAndConvertName(_name);
require(!_storage_.existingNames(_lowercase), "name exists");
require(_storage_.names(_id) == 0x0, "dragon already has a name");
_storage_.setName(_id, _initial, _lowercase);
return _initial;
}
}
| 216,817 | 819 |
56a4ed063623ccbb1239d913c1a9d6d934b09582af7972b9618af461356ab372
| 11,693 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x731Ceb99d31F4C8683629B70f2638e3AC11a4E82/contract.sol
| 3,137 | 11,172 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
interface IERC20 {
function totalSupply() external view returns (uint256 supply);
function balanceOf(address who) external view returns (uint256 balance);
function transfer(address to, uint256 value) external returns (bool trans1);
function transferFrom(address from,
address to,
uint256 value) external returns (bool trans);
}
interface ILP is IERC20 {
function token0() external view returns (IERC20);
function getReserves()
external
view
returns (uint112,
uint112,
uint32);
}
contract OwnableAndWhitelistble {
address public owner;
mapping(address => bool) internal whitelist;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event WhitelistAdded(address indexed sender, address indexed whitelistUser);
event WhitelistRemoved(address indexed sender, address indexed whitelistUser);
modifier onlyOwner() {
require(msg.sender == owner, "Only owner can call this function");
_;
}
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0), "You cant transfer ownerships to address 0x0");
require(newOwner != owner, "You cant transfer ownerships to yourself");
emit OwnershipTransferred(owner, newOwner);
whitelist[owner] = false;
whitelist[newOwner] = true;
owner = newOwner;
}
modifier onlyWhitelist() {
require(whitelist[msg.sender], "Only whitelist users can call this function");
_;
}
function addToWhitelist(address newWhitelistUser) external onlyOwner {
require(newWhitelistUser != address(0), "You cant add to whitelist address 0x0");
emit WhitelistAdded(msg.sender, newWhitelistUser);
whitelist[newWhitelistUser] = true;
}
function removeFromWhitelist(address newWhitelistUser) external onlyOwner {
require(whitelist[newWhitelistUser], "You cant remove from whitelist");
emit WhitelistRemoved(msg.sender, newWhitelistUser);
whitelist[newWhitelistUser] = false;
}
}
contract LPStaking is OwnableAndWhitelistble {
struct Stake {
uint256 amount;
uint256 startStaking;
uint256 lastHarvest;
uint256 bonus;
uint256 boost;
}
IERC20 mainToken;
address dividends;
uint256 public rate = 888;
uint256 public lowRate = 70;
uint256 public alpha = 1111;
uint256 public betta = 1;
mapping(ILP => uint256) public pools;
mapping(ILP => mapping(address => bool)) public userIncludes;
mapping(ILP => address[]) public users;
uint256 public constant cutoff = 48 hours;
uint256 public constant beforeCutoff = 15;
uint256 public constant afterCutoff = 10;
mapping(ILP => bool) public isPermittedLP;
mapping(address => mapping(ILP => Stake)) public stakes;
event Staked(address indexed who, ILP indexed lpToken, uint256 amount, uint256 startTime);
event AddedAmount(address indexed who, ILP indexed lpToken, uint256 amount);
event Harvested(address indexed who, ILP indexed lpToken, uint256 value, uint256 toDividends);
event Unstaked(address indexed who, ILP indexed lpToken, uint256 amount);
event Boosted(address indexed who, ILP indexed lpToken, uint256 boost);
event SettedPermisionLPToken(ILP indexed lpToken, bool perm);
event SettedAlpha(address indexed sender, uint256 alpha);
event SettedBetta(address indexed sender, uint256 betta);
event SettedLowRate(address indexed sender, uint256 lowRate);
event SettedDividends(address indexed sender, address indexed dividends);
constructor(address _owner,
IERC20 _token,
address _dividends) {
owner = _owner;
whitelist[_owner] = true;
mainToken = _token;
dividends = _dividends;
}
function stake(ILP _lpToken, uint256 _amount) external {
require(_amount > 0, "Amount must be greater then zero");
require(stakes[msg.sender][_lpToken].startStaking == 0, "You have already staked");
require(isPermittedLP[_lpToken], "You cant stake those LP tokens");
require(_lpToken.balanceOf(msg.sender) >= _amount, "You dont enough LP tokens");
require(_lpToken.transferFrom(msg.sender, address(this), _amount), "Transfer issues");
addBonuses(_lpToken, _amount);
pools[_lpToken] += _amount;
stakes[msg.sender][_lpToken] = Stake({
amount: _amount,
startStaking: block.timestamp,
lastHarvest: block.timestamp,
bonus: 0,
boost: 0
});
addUser(msg.sender, _lpToken);
emit Staked(msg.sender, _lpToken, _amount, block.timestamp);
}
function addAmount(uint256 _amount, ILP _lpToken) external {
require(_amount > 0, "Amount must be greater then zero");
require(stakes[msg.sender][_lpToken].startStaking != 0, "You dont have stake");
require(isPermittedLP[_lpToken], "You cant stake those LP tokens");
require(_lpToken.balanceOf(msg.sender) >= _amount, "You dont have enough LP tokens");
require(_lpToken.transferFrom(msg.sender, address(this), _amount), "Transfer issues");
addBonuses(_lpToken, _amount);
pools[_lpToken] += _amount;
stakes[msg.sender][_lpToken].amount += _amount;
emit AddedAmount(msg.sender, _lpToken, _amount);
}
function harvest(ILP _lpToken) public {
require(stakes[msg.sender][_lpToken].startStaking != 0, "You dont have stake");
(uint256 _value, uint256 _toDividends) = harvested(msg.sender, _lpToken);
require(mainToken.balanceOf(address(this)) >= (_value + _toDividends), "Contract doesnt have enough DES");
stakes[msg.sender][_lpToken].lastHarvest = block.timestamp;
stakes[msg.sender][_lpToken].bonus = 0;
require(mainToken.transfer(msg.sender, _value), "Transfer issues");
require(mainToken.transfer(dividends, _toDividends), "Transfer issues");
emit Harvested(msg.sender, _lpToken, _value, _toDividends);
}
function harvestedRaw(address _who,
ILP _lpToken,
uint256 _pool,
uint256 _time) public view returns (uint256 _value, uint256 _toDividends) {
require(stakes[_who][_lpToken].startStaking != 0, "You dont have stake");
if (stakes[_who][_lpToken].lastHarvest == 0) return (0, 0);
Stake memory _stake = stakes[_who][_lpToken];
uint256 _timePassed = _time - _stake.lastHarvest;
uint256 _percentDiv = _timePassed < cutoff ? beforeCutoff : afterCutoff;
uint256 _rewardInLP = (_stake.amount * _timePassed * (getRawRate(_pool) + _stake.boost)) /
(100 * (365 days)) +
_stake.bonus;
uint256 _toDivInLP = (_rewardInLP * _percentDiv) / 100;
uint256 _rewardInToken = LPtoToken(_lpToken, _rewardInLP);
uint256 _toDivInToken = LPtoToken(_lpToken, _toDivInLP);
return (_rewardInToken - _toDivInToken, _toDivInToken);
}
function LPtoToken(ILP _lpToken, uint256 _amountLP) public view returns (uint256) {
uint256 _totalSupply = _lpToken.totalSupply();
(uint112 r0, uint112 r1,) = _lpToken.getReserves();
if (mainToken == _lpToken.token0()) return (2 * r0 * _amountLP) / _totalSupply;
return (2 * r1 * _amountLP) / _totalSupply;
}
function harvested(address _who, ILP _lpToken) public view returns (uint256 _value, uint256 _toDividends) {
return harvestedRaw(_who, _lpToken, pools[_lpToken], block.timestamp);
}
function getRawRate(uint256 _pool) internal view returns (uint256 _rate) {
return ((rate - lowRate) * alpha * 1e18) / (_pool * betta + alpha * 1e18) + lowRate;
}
function getRate(ILP _lpToken) external view returns (uint256 _rate) {
return getRawRate(pools[_lpToken]);
}
function unstake(ILP _lpToken) public {
require(stakes[msg.sender][_lpToken].startStaking != 0, "You dont have stake");
harvest(_lpToken);
uint256 _amount = stakes[msg.sender][_lpToken].amount;
require(_lpToken.balanceOf(address(this)) >= _amount, "Contract doesnt have enough DES");
delete stakes[msg.sender][_lpToken];
removeUser(msg.sender, _lpToken);
require(_lpToken.transfer(msg.sender, _amount), "Transfer issues");
emit Unstaked(msg.sender, _lpToken, _amount);
}
function addUser(address _user, ILP _lpToken) internal returns (bool _status) {
users[_lpToken].push(_user);
userIncludes[_lpToken][_user] = true;
return true;
}
function removeUser(address _user, ILP _lpToken) internal returns (bool _status) {
uint256 _length = users[_lpToken].length;
address[] memory _users = users[_lpToken];
for (uint256 i = 0; i < _length; i++) {
if (_users[i] == _user) {
users[_lpToken][i] = _users[_length - 1];
users[_lpToken].pop();
userIncludes[_lpToken][_user] = false;
return true;
}
}
return false;
}
function addBonuses(ILP _lpToken, uint256 _amount) internal {
uint256 _length = users[_lpToken].length;
address[] memory _users = users[_lpToken];
uint256 _oldPool = pools[_lpToken];
uint256 _newPool = _oldPool + _amount;
for (uint256 i = 0; i < _length; i++) {
if (userIncludes[_lpToken][_users[i]]) {
(uint256 _oldVal,) = harvestedRaw(_users[i], _lpToken, _oldPool, block.timestamp);
(uint256 _newVal,) = harvestedRaw(_users[i], _lpToken, _newPool, block.timestamp);
stakes[_users[i]][_lpToken].bonus += _oldVal - _newVal;
}
}
}
function getUsers(ILP _lpToken) public view returns (address[] memory) {
return users[_lpToken];
}
function getStake(address _user, ILP _lpToken) external view returns (Stake memory) {
return stakes[_user][_lpToken];
}
function setBoost(address _for,
ILP _lpToken,
uint256 _boost) external onlyWhitelist {
stakes[_for][_lpToken].boost = _boost;
emit Boosted(_for, _lpToken, _boost);
}
function setDividends(address _newDividends) external onlyOwner {
dividends = _newDividends;
emit SettedDividends(msg.sender, _newDividends);
}
function setAlpha(uint256 _alpha) external onlyOwner {
require(_alpha > 0, "Alpha is incorrect");
alpha = _alpha;
emit SettedAlpha(msg.sender, _alpha);
}
function setBetta(uint256 _betta) external onlyOwner {
require(_betta >= 1, "Betta is incorrect");
betta = _betta;
emit SettedBetta(msg.sender, _betta);
}
function setLowRate(uint256 _lowRate) external onlyOwner {
lowRate = _lowRate;
emit SettedLowRate(msg.sender, _lowRate);
}
function setPermissionLP(ILP _lpToken, bool _perm) external onlyOwner {
isPermittedLP[_lpToken] = _perm;
emit SettedPermisionLPToken(_lpToken, _perm);
}
}
| 252,153 | 820 |
d6716a1fc12c3bd1d1a8e7f9a575d2cda22c8a7a2605c6034d179d78bba921d8
| 34,026 |
.sol
|
Solidity
| false |
533848169
|
llamaxyz/aave-v3-crosschain-maticx-listing
|
81159a8dbfaa8421da47bdb708915ef1ddd7d564
|
lib/aave-address-book/src/AaveV2.sol
| 3,177 | 13,786 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0;
library DataTypes {
// refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties.
struct ReserveData {
//stores the reserve configuration
ReserveConfigurationMap configuration;
//the liquidity index. Expressed in ray
uint128 liquidityIndex;
//variable borrow index. Expressed in ray
uint128 variableBorrowIndex;
//the current supply rate. Expressed in ray
uint128 currentLiquidityRate;
//the current variable borrow rate. Expressed in ray
uint128 currentVariableBorrowRate;
//the current stable borrow rate. Expressed in ray
uint128 currentStableBorrowRate;
uint40 lastUpdateTimestamp;
//tokens addresses
address aTokenAddress;
address stableDebtTokenAddress;
address variableDebtTokenAddress;
//address of the interest rate strategy
address interestRateStrategyAddress;
//the id of the reserve. Represents the position in the list of the active reserves
uint8 id;
}
struct ReserveConfigurationMap {
//bit 0-15: LTV
//bit 16-31: Liq. threshold
//bit 32-47: Liq. bonus
//bit 48-55: Decimals
//bit 56: Reserve is active
//bit 57: reserve is frozen
//bit 58: borrowing is enabled
//bit 59: stable rate borrowing enabled
//bit 60-63: reserved
//bit 64-79: reserve factor
uint256 data;
}
struct UserConfigurationMap {
uint256 data;
}
enum InterestRateMode {
NONE,
STABLE,
VARIABLE
}
}
library ConfiguratorInputTypes {
struct InitReserveInput {
address aTokenImpl;
address stableDebtTokenImpl;
address variableDebtTokenImpl;
uint8 underlyingAssetDecimals;
address interestRateStrategyAddress;
address underlyingAsset;
address treasury;
address incentivesController;
string underlyingAssetName;
string aTokenName;
string aTokenSymbol;
string variableDebtTokenName;
string variableDebtTokenSymbol;
string stableDebtTokenName;
string stableDebtTokenSymbol;
bytes params;
}
struct UpdateATokenInput {
address asset;
address treasury;
address incentivesController;
string name;
string symbol;
address implementation;
bytes params;
}
struct UpdateDebtTokenInput {
address asset;
address incentivesController;
string name;
string symbol;
address implementation;
bytes params;
}
}
interface ILendingPoolAddressesProvider {
event MarketIdSet(string newMarketId);
event LendingPoolUpdated(address indexed newAddress);
event ConfigurationAdminUpdated(address indexed newAddress);
event EmergencyAdminUpdated(address indexed newAddress);
event LendingPoolConfiguratorUpdated(address indexed newAddress);
event LendingPoolCollateralManagerUpdated(address indexed newAddress);
event PriceOracleUpdated(address indexed newAddress);
event LendingRateOracleUpdated(address indexed newAddress);
event ProxyCreated(bytes32 id, address indexed newAddress);
event AddressSet(bytes32 id, address indexed newAddress, bool hasProxy);
function getMarketId() external view returns (string memory);
function setMarketId(string calldata marketId) external;
function setAddress(bytes32 id, address newAddress) external;
function setAddressAsProxy(bytes32 id, address impl) external;
function getAddress(bytes32 id) external view returns (address);
function getLendingPool() external view returns (address);
function setLendingPoolImpl(address pool) external;
function getLendingPoolConfigurator() external view returns (address);
function setLendingPoolConfiguratorImpl(address configurator) external;
function getLendingPoolCollateralManager() external view returns (address);
function setLendingPoolCollateralManager(address manager) external;
function getPoolAdmin() external view returns (address);
function setPoolAdmin(address admin) external;
function getEmergencyAdmin() external view returns (address);
function setEmergencyAdmin(address admin) external;
function getPriceOracle() external view returns (address);
function setPriceOracle(address priceOracle) external;
function getLendingRateOracle() external view returns (address);
function setLendingRateOracle(address lendingRateOracle) external;
}
interface ILendingPool {
event Deposit(address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint16 indexed referral);
event Withdraw(address indexed reserve,
address indexed user,
address indexed to,
uint256 amount);
event Borrow(address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint256 borrowRateMode,
uint256 borrowRate,
uint16 indexed referral);
event Repay(address indexed reserve,
address indexed user,
address indexed repayer,
uint256 amount);
event Swap(address indexed reserve, address indexed user, uint256 rateMode);
event ReserveUsedAsCollateralEnabled(address indexed reserve,
address indexed user);
event ReserveUsedAsCollateralDisabled(address indexed reserve,
address indexed user);
event RebalanceStableBorrowRate(address indexed reserve,
address indexed user);
event FlashLoan(address indexed target,
address indexed initiator,
address indexed asset,
uint256 amount,
uint256 premium,
uint16 referralCode);
event Paused();
event Unpaused();
event LiquidationCall(address indexed collateralAsset,
address indexed debtAsset,
address indexed user,
uint256 debtToCover,
uint256 liquidatedCollateralAmount,
address liquidator,
bool receiveAToken);
event ReserveDataUpdated(address indexed reserve,
uint256 liquidityRate,
uint256 stableBorrowRate,
uint256 variableBorrowRate,
uint256 liquidityIndex,
uint256 variableBorrowIndex);
function deposit(address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode) external;
function withdraw(address asset,
uint256 amount,
address to) external returns (uint256);
function borrow(address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf) external;
function repay(address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf) external returns (uint256);
function swapBorrowRateMode(address asset, uint256 rateMode) external;
function rebalanceStableBorrowRate(address asset, address user) external;
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
external;
function liquidationCall(address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken) external;
function flashLoan(address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode) external;
function getUserAccountData(address user)
external
view
returns (uint256 totalCollateralETH,
uint256 totalDebtETH,
uint256 availableBorrowsETH,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor);
function initReserve(address reserve,
address aTokenAddress,
address stableDebtAddress,
address variableDebtAddress,
address interestRateStrategyAddress) external;
function setReserveInterestRateStrategyAddress(address reserve,
address rateStrategyAddress) external;
function setConfiguration(address reserve, uint256 configuration) external;
function getConfiguration(address asset)
external
view
returns (DataTypes.ReserveConfigurationMap memory);
function getUserConfiguration(address user)
external
view
returns (DataTypes.UserConfigurationMap memory);
function getReserveNormalizedIncome(address asset)
external
view
returns (uint256);
function getReserveNormalizedVariableDebt(address asset)
external
view
returns (uint256);
function getReserveData(address asset)
external
view
returns (DataTypes.ReserveData memory);
function finalizeTransfer(address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromAfter,
uint256 balanceToBefore) external;
function getReservesList() external view returns (address[] memory);
function getAddressesProvider()
external
view
returns (ILendingPoolAddressesProvider);
function setPause(bool val) external;
function paused() external view returns (bool);
}
interface ILendingPoolConfigurator {
event ReserveInitialized(address indexed asset,
address indexed aToken,
address stableDebtToken,
address variableDebtToken,
address interestRateStrategyAddress);
event BorrowingEnabledOnReserve(address indexed asset,
bool stableRateEnabled);
event BorrowingDisabledOnReserve(address indexed asset);
event CollateralConfigurationChanged(address indexed asset,
uint256 ltv,
uint256 liquidationThreshold,
uint256 liquidationBonus);
event StableRateEnabledOnReserve(address indexed asset);
event StableRateDisabledOnReserve(address indexed asset);
event ReserveActivated(address indexed asset);
event ReserveDeactivated(address indexed asset);
event ReserveFrozen(address indexed asset);
event ReserveUnfrozen(address indexed asset);
event ReserveFactorChanged(address indexed asset, uint256 factor);
event ReserveDecimalsChanged(address indexed asset, uint256 decimals);
event ReserveInterestRateStrategyChanged(address indexed asset,
address strategy);
event ATokenUpgraded(address indexed asset,
address indexed proxy,
address indexed implementation);
event StableDebtTokenUpgraded(address indexed asset,
address indexed proxy,
address indexed implementation);
event VariableDebtTokenUpgraded(address indexed asset,
address indexed proxy,
address indexed implementation);
function initReserve(address aTokenImpl,
address stableDebtTokenImpl,
address variableDebtTokenImpl,
uint8 underlyingAssetDecimals,
address interestRateStrategyAddress) external;
function batchInitReserve(ConfiguratorInputTypes.InitReserveInput[] calldata input) external;
function updateAToken(address asset, address implementation) external;
function updateStableDebtToken(address asset, address implementation)
external;
function updateVariableDebtToken(address asset, address implementation)
external;
function enableBorrowingOnReserve(address asset, bool stableBorrowRateEnabled)
external;
function disableBorrowingOnReserve(address asset) external;
function configureReserveAsCollateral(address asset,
uint256 ltv,
uint256 liquidationThreshold,
uint256 liquidationBonus) external;
function enableReserveStableRate(address asset) external;
function disableReserveStableRate(address asset) external;
function activateReserve(address asset) external;
function deactivateReserve(address asset) external;
function freezeReserve(address asset) external;
function unfreezeReserve(address asset) external;
function setReserveFactor(address asset, uint256 reserveFactor) external;
function setReserveInterestRateStrategyAddress(address asset,
address rateStrategyAddress) external;
function setPoolPause(bool val) external;
}
interface IAaveOracle {
event WethSet(address indexed weth);
event AssetSourceUpdated(address indexed asset, address indexed source);
event FallbackOracleUpdated(address indexed fallbackOracle);
/// @notice Returns the WETH address (reference asset of the oracle)
function WETH() external returns (address);
/// @notice External function called by the Aave governance to set or replace sources of assets
/// @param assets The addresses of the assets
/// @param sources The address of the source of each asset
function setAssetSources(address[] calldata assets,
address[] calldata sources) external;
/// @notice Sets the fallbackOracle
/// - Callable only by the Aave governance
/// @param fallbackOracle The address of the fallbackOracle
function setFallbackOracle(address fallbackOracle) external;
/// @notice Gets an asset price by address
/// @param asset The asset address
function getAssetPrice(address asset) external view returns (uint256);
/// @notice Gets a list of prices from a list of assets addresses
/// @param assets The list of assets addresses
function getAssetsPrices(address[] calldata assets)
external
view
returns (uint256[] memory);
/// @notice Gets the address of the source for an asset address
/// @param asset The address of the asset
/// @return address The address of the source
function getSourceOfAsset(address asset) external view returns (address);
/// @notice Gets the address of the fallback oracle
/// @return address The addres of the fallback oracle
function getFallbackOracle() external view returns (address);
}
struct TokenData {
string symbol;
address tokenAddress;
}
// TODO: incomplete interface
interface IAaveProtocolDataProvider {
function getReserveConfigurationData(address asset)
external
view
returns (uint256 decimals,
uint256 ltv,
uint256 liquidationThreshold,
uint256 liquidationBonus,
uint256 reserveFactor,
bool usageAsCollateralEnabled,
bool borrowingEnabled,
bool stableBorrowRateEnabled,
bool isActive,
bool isFrozen);
function getAllReservesTokens() external view returns (TokenData[] memory);
function getReserveTokensAddresses(address asset)
external
view
returns (address aTokenAddress,
address stableDebtTokenAddress,
address variableDebtTokenAddress);
}
| 2,169 | 821 |
505b6687255cd96af5ddec03fca5d19156b1e530b31349f2a5a1932c939c2a21
| 16,691 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TS16jJhyvfzj4Za6kq811CvoLqWhC1HUvK_TribalWarToken.sol
| 2,962 | 11,133 |
//SourceUnit: TWToken.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract TribalWarToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'TribalWarToken';
string private _symbol = 'TW';
uint8 private _decimals = 6;
uint256 private _totalSupply = 6666 * 10**uint256(_decimals);
address private _burnPool = address(0);
uint256 public _burnFee = 2;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 10;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public MAX_STOP_FEE_TOTAL = 1000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () public {
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity);
return (tTransferAmount, tBurn, tLiquidity);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_liquidityFee = 0;
_burnFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
}
}
| 285,976 | 822 |
67693573dd841313be98b29f06e3bd0cdca64774e00a735a7d9940e8a26aa530
| 12,760 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/cb/cb9f441ffae898e7a2f32143fd79ac899517a9dc_AnyswapV6Router.sol
| 3,265 | 11,945 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.10;
library TransferHelper {
function safeTransferNative(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: NATIVE_TRANSFER_FAILED');
}
}
interface IwNATIVE {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
interface AnyswapV1ERC20 {
function mint(address to, uint256 amount) external returns (bool);
function burn(address from, uint256 amount) external returns (bool);
function setMinter(address _auth) external;
function applyMinter() external;
function revokeMinter(address _auth) external;
function changeVault(address newVault) external returns (bool);
function depositVault(uint amount, address to) external returns (uint);
function withdrawVault(address from, uint amount, address to) external returns (uint);
function underlying() external view returns (address);
function deposit(uint amount, address to) external returns (uint);
function withdraw(uint amount, address to) external returns (uint);
}
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) {
return account.code.length > 0;
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6Router {
using SafeERC20 for IERC20;
address public constant factory = address(0);
address public immutable wNATIVE;
// delay for timelock functions
uint public constant DELAY = 2 days;
constructor(address _wNATIVE, address _mpc) {
_newMPC = _mpc;
_newMPCEffectiveTime = block.timestamp;
wNATIVE = _wNATIVE;
}
receive() external payable {
assert(msg.sender == wNATIVE); // only accept Native via fallback from the wNative contract
}
address private _oldMPC;
address private _newMPC;
uint256 private _newMPCEffectiveTime;
event LogChangeMPC(address indexed oldMPC, address indexed newMPC, uint indexed effectiveTime, uint chainID);
event LogAnySwapIn(bytes32 indexed txhash, address indexed token, address indexed to, uint amount, uint fromChainID, uint toChainID);
event LogAnySwapOut(address indexed token, address indexed from, address indexed to, uint amount, uint fromChainID, uint toChainID);
event LogAnySwapOut(address indexed token, address indexed from, string to, uint amount, uint fromChainID, uint toChainID);
modifier onlyMPC() {
require(msg.sender == mpc(), "AnyswapV6Router: FORBIDDEN");
_;
}
function mpc() public view returns (address) {
if (block.timestamp >= _newMPCEffectiveTime) {
return _newMPC;
}
return _oldMPC;
}
function cID() public view returns (uint) {
return block.chainid;
}
function changeMPC(address newMPC) external onlyMPC returns (bool) {
require(newMPC != address(0), "AnyswapV6Router: address(0)");
_oldMPC = mpc();
_newMPC = newMPC;
_newMPCEffectiveTime = block.timestamp + DELAY;
emit LogChangeMPC(_oldMPC, _newMPC, _newMPCEffectiveTime, cID());
return true;
}
function changeVault(address token, address newVault) external onlyMPC returns (bool) {
return AnyswapV1ERC20(token).changeVault(newVault);
}
function setMinter(address token, address _auth) external onlyMPC {
return AnyswapV1ERC20(token).setMinter(_auth);
}
function applyMinter(address token) external onlyMPC {
return AnyswapV1ERC20(token).applyMinter();
}
function revokeMinter(address token, address _auth) external onlyMPC {
return AnyswapV1ERC20(token).revokeMinter(_auth);
}
function _anySwapOut(address from, address token, address to, uint amount, uint toChainID) internal {
AnyswapV1ERC20(token).burn(from, amount);
emit LogAnySwapOut(token, from, to, amount, cID(), toChainID);
}
// Swaps `amount` `token` from this chain to `toChainID` chain with recipient `to`
function anySwapOut(address token, address to, uint amount, uint toChainID) external {
_anySwapOut(msg.sender, token, to, amount, toChainID);
}
function anySwapOutUnderlying(address token, address to, uint amount, uint toChainID) external {
address _underlying = AnyswapV1ERC20(token).underlying();
require(_underlying != address(0), "AnyswapV6Router: no underlying");
IERC20(_underlying).safeTransferFrom(msg.sender, token, amount);
emit LogAnySwapOut(token, msg.sender, to, amount, cID(), toChainID);
}
function anySwapOutNative(address token, address to, uint toChainID) external payable {
require(wNATIVE != address(0), "AnyswapV6Router: zero wNATIVE");
require(AnyswapV1ERC20(token).underlying() == wNATIVE, "AnyswapV6Router: underlying is not wNATIVE");
IwNATIVE(wNATIVE).deposit{value: msg.value}();
assert(IwNATIVE(wNATIVE).transfer(token, msg.value));
emit LogAnySwapOut(token, msg.sender, to, msg.value, cID(), toChainID);
}
function anySwapOut(address[] calldata tokens, address[] calldata to, uint[] calldata amounts, uint[] calldata toChainIDs) external {
for (uint i = 0; i < tokens.length; i++) {
_anySwapOut(msg.sender, tokens[i], to[i], amounts[i], toChainIDs[i]);
}
}
function anySwapOut(address token, string memory to, uint amount, uint toChainID) external {
AnyswapV1ERC20(token).burn(msg.sender, amount);
emit LogAnySwapOut(token, msg.sender, to, amount, cID(), toChainID);
}
function anySwapOutUnderlying(address token, string memory to, uint amount, uint toChainID) external {
address _underlying = AnyswapV1ERC20(token).underlying();
require(_underlying != address(0), "AnyswapV6Router: no underlying");
IERC20(_underlying).safeTransferFrom(msg.sender, token, amount);
emit LogAnySwapOut(token, msg.sender, to, amount, cID(), toChainID);
}
function anySwapOutNative(address token, string memory to, uint toChainID) external payable {
require(wNATIVE != address(0), "AnyswapV6Router: zero wNATIVE");
require(AnyswapV1ERC20(token).underlying() == wNATIVE, "AnyswapV6Router: underlying is not wNATIVE");
IwNATIVE(wNATIVE).deposit{value: msg.value}();
assert(IwNATIVE(wNATIVE).transfer(token, msg.value));
emit LogAnySwapOut(token, msg.sender, to, msg.value, cID(), toChainID);
}
// swaps `amount` `token` in `fromChainID` to `to` on this chainID
function _anySwapIn(bytes32 txs, address token, address to, uint amount, uint fromChainID) internal {
AnyswapV1ERC20(token).mint(to, amount);
emit LogAnySwapIn(txs, token, to, amount, fromChainID, cID());
}
// swaps `amount` `token` in `fromChainID` to `to` on this chainID
// triggered by `anySwapOut`
function anySwapIn(bytes32 txs, address token, address to, uint amount, uint fromChainID) external onlyMPC {
_anySwapIn(txs, token, to, amount, fromChainID);
}
// swaps `amount` `token` in `fromChainID` to `to` on this chainID with `to` receiving `underlying`
function anySwapInUnderlying(bytes32 txs, address token, address to, uint amount, uint fromChainID) external onlyMPC {
_anySwapIn(txs, token, to, amount, fromChainID);
AnyswapV1ERC20(token).withdrawVault(to, amount, to);
}
function anySwapInAuto(bytes32 txs, address token, address to, uint amount, uint fromChainID) external onlyMPC {
_anySwapIn(txs, token, to, amount, fromChainID);
AnyswapV1ERC20 _anyToken = AnyswapV1ERC20(token);
address _underlying = _anyToken.underlying();
if (_underlying != address(0) && IERC20(_underlying).balanceOf(token) >= amount) {
if (_underlying == wNATIVE) {
_anyToken.withdrawVault(to, amount, address(this));
IwNATIVE(wNATIVE).withdraw(amount);
TransferHelper.safeTransferNative(to, amount);
} else {
_anyToken.withdrawVault(to, amount, to);
}
}
}
function depositNative(address token, address to) external payable returns (uint) {
require(wNATIVE != address(0), "AnyswapV6Router: zero wNATIVE");
require(AnyswapV1ERC20(token).underlying() == wNATIVE, "AnyswapV6Router: underlying is not wNATIVE");
IwNATIVE(wNATIVE).deposit{value: msg.value}();
assert(IwNATIVE(wNATIVE).transfer(token, msg.value));
AnyswapV1ERC20(token).depositVault(msg.value, to);
return msg.value;
}
function withdrawNative(address token, uint amount, address to) external returns (uint) {
require(wNATIVE != address(0), "AnyswapV6Router: zero wNATIVE");
require(AnyswapV1ERC20(token).underlying() == wNATIVE, "AnyswapV6Router: underlying is not wNATIVE");
uint256 old_balance = IERC20(wNATIVE).balanceOf(address(this));
AnyswapV1ERC20(token).withdrawVault(msg.sender, amount, address(this));
uint256 new_balance = IERC20(wNATIVE).balanceOf(address(this));
assert(new_balance == old_balance + amount);
IwNATIVE(wNATIVE).withdraw(amount);
TransferHelper.safeTransferNative(to, amount);
return amount;
}
// extracts mpc fee from bridge fees
function anySwapFeeTo(address token, uint amount) external onlyMPC {
address _mpc = mpc();
AnyswapV1ERC20(token).mint(_mpc, amount);
AnyswapV1ERC20(token).withdrawVault(_mpc, amount, _mpc);
}
function anySwapIn(bytes32[] calldata txs, address[] calldata tokens, address[] calldata to, uint256[] calldata amounts, uint[] calldata fromChainIDs) external onlyMPC {
for (uint i = 0; i < tokens.length; i++) {
_anySwapIn(txs[i], tokens[i], to[i], amounts[i], fromChainIDs[i]);
}
}
}
| 26,953 | 823 |
2aacff4513ffef85166257d228d11513bc55c2a17a818a338293dd0d880dcc8b
| 9,683 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xe507c467c0f63845eadce5516c9ff5e1a5ebb63a.sol
| 2,026 | 8,260 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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 CaiShen is Ownable {
struct Gift {
bool exists; // 0 Only true if this exists
uint giftId; // 1 The gift ID
address giver; // 2 The address of the giver
address recipient; // 3 The address of the recipient
uint expiry; // 4 The expiry datetime of the timelock as a
// Unix timestamp
uint amount; // 5 The amount of ETH
bool redeemed; // 6 Whether the funds have already been redeemed
string giverName; // 7 The giver's name
string message; // 8 A message from the giver to the recipient
uint timestamp; // 9 The timestamp of when the gift was given
}
// Total fees gathered since the start of the contract or the last time
// fees were collected, whichever is latest
uint public feesGathered;
// Each gift has a unique ID. If you increment this value, you will get
// an unused gift ID.
uint public nextGiftId;
// Maps each recipient address to a list of giftIDs of Gifts they have
// received.
mapping (address => uint[]) public recipientToGiftIds;
// Maps each gift ID to its associated gift.
mapping (uint => Gift) public giftIdToGift;
event Constructed (address indexed by, uint indexed amount);
event CollectedAllFees (address indexed by, uint indexed amount);
event DirectlyDeposited(address indexed from, uint indexed amount);
event Gave (uint indexed giftId,
address indexed giver,
address indexed recipient,
uint amount, uint expiry);
event Redeemed (uint indexed giftId,
address indexed giver,
address indexed recipient,
uint amount);
// Constructor
function CaiShen() public payable {
Constructed(msg.sender, msg.value);
}
// Fallback function which allows this contract to receive funds.
function () public payable {
// Sending ETH directly to this contract does nothing except log an
// event.
DirectlyDeposited(msg.sender, msg.value);
}
//// Getter functions:
function getGiftIdsByRecipient (address recipient)
public view returns (uint[]) {
return recipientToGiftIds[recipient];
}
//// Contract functions:
// Call this function while sending ETH to give a gift.
// @recipient: the recipient's address
// @expiry: the Unix timestamp of the expiry datetime.
// @giverName: the name of the giver
// @message: a personal message
// Tested in test/test_give.js and test/TestGive.sol
function give (address recipient, uint expiry, string giverName, string message)
public payable returns (uint) {
address giver = msg.sender;
// Validate the giver address
assert(giver != address(0));
// The gift must be a positive amount of ETH
uint amount = msg.value;
require(amount > 0);
// The expiry datetime must be in the future.
// The possible drift is only 12 minutes.
require(expiry > now);
// The giver and the recipient must be different addresses
require(giver != recipient);
// The recipient must be a valid address
require(recipient != address(0));
// Make sure nextGiftId is 0 or positive, or this contract is buggy
assert(nextGiftId >= 0);
// Calculate the contract owner's fee
uint feeTaken = fee(amount);
assert(feeTaken >= 0);
// Increment feesGathered
feesGathered = SafeMath.add(feesGathered, feeTaken);
// Shave off the fee from the amount
uint amtGiven = SafeMath.sub(amount, feeTaken);
assert(amtGiven > 0);
// If a gift with this new gift ID already exists, this contract is buggy.
assert(giftIdToGift[nextGiftId].exists == false);
// Update the mappings
recipientToGiftIds[recipient].push(nextGiftId);
giftIdToGift[nextGiftId] =
Gift(true, nextGiftId, giver, recipient, expiry,
amtGiven, false, giverName, message, now);
uint giftId = nextGiftId;
// Increment nextGiftId
nextGiftId = SafeMath.add(giftId, 1);
// If a gift with this new gift ID already exists, this contract is buggy.
assert(giftIdToGift[nextGiftId].exists == false);
// Log the event
Gave(giftId, giver, recipient, amount, expiry);
return giftId;
}
// Call this function to redeem a gift of ETH.
// Tested in test/test_redeem.js
function redeem (uint giftId) public {
// The giftID should be 0 or positive
require(giftId >= 0);
// The gift must exist and must not have already been redeemed
require(isValidGift(giftIdToGift[giftId]));
// The recipient must be the caller of this function
address recipient = giftIdToGift[giftId].recipient;
require(recipient == msg.sender);
// The current datetime must be the same or after the expiry timestamp
require(now >= giftIdToGift[giftId].expiry);
//// If the following assert statements are triggered, this contract is
//// buggy.
// The amount must be positive because this is required in give()
uint amount = giftIdToGift[giftId].amount;
assert(amount > 0);
// The giver must not be the recipient because this was asserted in give()
address giver = giftIdToGift[giftId].giver;
assert(giver != recipient);
// Make sure the giver is valid because this was asserted in give();
assert(giver != address(0));
// Update the gift to mark it as redeemed, so that the funds cannot be
// double-spent
giftIdToGift[giftId].redeemed = true;
// Transfer the funds
recipient.transfer(amount);
// Log the event
Redeemed(giftId, giftIdToGift[giftId].giver, recipient, amount);
}
// Calculate the contract owner's fee
// Tested in test/test_fee.js
function fee (uint amount) public pure returns (uint) {
if (amount <= 0.01 ether) {
return 0;
} else if (amount > 0.01 ether) {
return SafeMath.div(amount, 100);
}
}
// Transfer the fees collected thus far to the contract owner.
// Only the contract owner may invoke this function.
// Tested in test/test_collect_fees.js
function collectAllFees () public onlyOwner {
// Store the fee amount in a temporary variable
uint amount = feesGathered;
// Make sure that the amount is positive
require(amount > 0);
// Set the feesGathered state variable to 0
feesGathered = 0;
// Make the transfer
owner.transfer(amount);
CollectedAllFees(owner, amount);
}
// Returns true only if the gift exists and has not already been
// redeemed
function isValidGift(Gift gift) private pure returns (bool) {
return gift.exists == true && gift.redeemed == false;
}
}
| 335,505 | 824 |
8e7a8a8b9af1618b8309edb1fc72a9d2eeb223a652f20fac212e00343b918a22
| 33,568 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/90/90f297365759a7f7d66544694fa9dc1081a227bb_PsiPresale.sol
| 4,090 | 16,158 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function policy() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable{
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function policy() public view override returns (address) {
return _owner;
}
modifier onlyPolicy() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyPolicy() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyPolicy() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
contract PsiPresale is Ownable {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
uint256 public constant PSI_UNIT_PRICE = 10;
uint256 public constant PSI_PER_ENTRY = 30;
uint256 public totalEntry = 0;
uint256 public constant MAX_ENTRIES = 1000;
uint256 public constant MAX_ENTRIES_PER_ADDRESS = 3;
struct InvestorDetails {
uint256 nbEntry;
bool hasClaimed;
}
mapping(address => InvestorDetails) public investors;
address public baseToken;
address public farmingToken;
uint256 depositTimestamp;
uint256 claimTimestamp;
bool initClaimBlock = false;
event Deposit(address indexed investor, uint256 nbEntry);
event Claim(address indexed investor);
constructor(address _baseToken, address _farmingToken, uint256 _depositTimestamp) {
baseToken = _baseToken;
farmingToken = _farmingToken;
depositTimestamp = _depositTimestamp;
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
// Deposit token to the contract
function deposit(uint256 _nbEntry) public onlyEOA {
require(depositTimestamp <= block.timestamp, "!start");
require(totalEntry.add(_nbEntry) <= MAX_ENTRIES, "Should exceed total entries");
require(_nbEntry > 0 && investors[msg.sender].nbEntry.add(_nbEntry) <= MAX_ENTRIES_PER_ADDRESS, "Nb entries invalid per address");
IERC20(baseToken).transferFrom(msg.sender, address(this), getAmountToSend(_nbEntry));
investors[msg.sender].nbEntry = investors[msg.sender].nbEntry.add(_nbEntry);
totalEntry = totalEntry.add(_nbEntry);
emit Deposit(msg.sender, _nbEntry);
}
// Claim PSI token from contract
function claim() public onlyEOA {
require(initClaimBlock, "!init");
require(claimTimestamp <= block.timestamp, "!start");
require(!investors[msg.sender].hasClaimed, 'already claimed');
investors[msg.sender].hasClaimed = true;
IERC20(farmingToken).transfer(msg.sender, getAmountToClaim(investors[msg.sender].nbEntry));
emit Claim(msg.sender);
}
// Edit claim timestamp
function setClaimTimestamp(uint256 _claimTimestamp) external onlyPolicy {
claimTimestamp = _claimTimestamp;
initClaimBlock = true;
}
// Update deposit timestamp
function setDepositTimestamp(uint256 _depositTimestamp) external onlyPolicy {
depositTimestamp = _depositTimestamp;
}
// Dev can withdraw tokens of the contract
function withdraw(address _token) external onlyPolicy{
IERC20(_token).transfer(policy(), IERC20(_token).balanceOf(address(this)));
}
function getCurrentTimestamp() view external returns(uint256){
return block.timestamp;
}
function getAmountToSend(uint256 _nbEntry) private view returns (uint256) {
return _nbEntry
.mul(PSI_PER_ENTRY)
.mul(PSI_UNIT_PRICE)
.mul(10 ** (ERC20(baseToken).decimals()));
}
function getAmountToClaim(uint256 _nbEntry) private view returns (uint256) {
return _nbEntry
.mul(PSI_PER_ENTRY)
.mul(10 ** (ERC20(farmingToken).decimals()));
}
}
| 89,822 | 825 |
3703f2ee0c08e7ee52ae923f2332fb8fb1a074d0c6aa4c7fe58b09183f9f76ed
| 27,428 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8f/8F87a740B9036cdaE2199a7508beC49c3162193A_SantaSperm.sol
| 4,445 | 16,396 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.7.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SantaSperm is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'SantaSperm';
string private _symbol = 'SANTASPERM';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 75,699 | 826 |
93a74d74f1d6e0682cbbe800578bbc61c8755e7b6e18ff9d21991cf160eccd2e
| 12,137 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xeb021dd3e42dc6fdb6cde54d0c4a09f82a6bca29.sol
| 3,209 | 11,869 |
pragma solidity ^0.4.18;
//
// FogLink OS Token
// Author: FNK
// Contact: support@foglink.io
// Telegram community: https://t.me/fnkofficial
//
contract FNKOSToken {
string public constant name = "FNKOSToken";
string public constant symbol = "FNKOS";
uint public constant decimals = 18;
uint256 fnkEthRate = 10 ** decimals;
uint256 fnkSupply = 1000000000;
uint256 public totalSupply = fnkSupply * fnkEthRate;
uint256 public minInvEth = 0.1 ether;
uint256 public maxInvEth = 100.0 ether;
uint256 public sellStartTime = 1524240000; // 2018/4/21
uint256 public sellDeadline1 = sellStartTime + 30 days;
uint256 public sellDeadline2 = sellDeadline1 + 30 days;
uint256 public freezeDuration = 30 days;
uint256 public ethFnkRate1 = 3600;
uint256 public ethFnkRate2 = 3600;
bool public running = true;
bool public buyable = true;
address owner;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public whitelist;
mapping (address => uint256) whitelistLimit;
struct BalanceInfo {
uint256 balance;
uint256[] freezeAmount;
uint256[] releaseTime;
}
mapping (address => BalanceInfo) balances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event BeginRunning();
event PauseRunning();
event BeginSell();
event PauseSell();
event Burn(address indexed burner, uint256 val);
event Freeze(address indexed from, uint256 value);
function FNKOSToken () public{
owner = msg.sender;
balances[owner].balance = totalSupply;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyWhitelist() {
require(whitelist[msg.sender] == true);
_;
}
modifier isRunning(){
require(running);
_;
}
modifier isNotRunning(){
require(!running);
_;
}
modifier isBuyable(){
require(buyable && now >= sellStartTime && now <= sellDeadline2);
_;
}
modifier isNotBuyable(){
require(!buyable || now < sellStartTime || now > sellDeadline2);
_;
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
// 1eth = newRate tokens
function setPbulicOfferingPrice(uint256 _rate1, uint256 _rate2) onlyOwner public {
ethFnkRate1 = _rate1;
ethFnkRate2 = _rate2;
}
//
function setPublicOfferingLimit(uint256 _minVal, uint256 _maxVal) onlyOwner public {
minInvEth = _minVal;
maxInvEth = _maxVal;
}
function setPublicOfferingDate(uint256 _startTime, uint256 _deadLine1, uint256 _deadLine2) onlyOwner public {
sellStartTime = _startTime;
sellDeadline1 = _deadLine1;
sellDeadline2 = _deadLine2;
}
function transferOwnership(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function pause() onlyOwner isRunning public {
running = false;
PauseRunning();
}
function start() onlyOwner isNotRunning public {
running = true;
BeginRunning();
}
function pauseSell() onlyOwner isBuyable isRunning public{
buyable = false;
PauseSell();
}
function beginSell() onlyOwner isNotBuyable isRunning public{
buyable = true;
BeginSell();
}
//
// _amount in FNK,
//
function airDeliver(address _to, uint256 _amount) onlyOwner public {
require(owner != _to);
require(_amount > 0);
require(balances[owner].balance >= _amount);
// take big number as wei
if(_amount < fnkSupply){
_amount = _amount * fnkEthRate;
}
balances[owner].balance = safeSub(balances[owner].balance, _amount);
balances[_to].balance = safeAdd(balances[_to].balance, _amount);
Transfer(owner, _to, _amount);
}
function airDeliverMulti(address[] _addrs, uint256 _amount) onlyOwner public {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amount);
}
}
function airDeliverStandalone(address[] _addrs, uint256[] _amounts) onlyOwner public {
require(_addrs.length <= 255);
require(_addrs.length == _amounts.length);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amounts[i]);
}
}
//
// _amount, _freezeAmount in FNK
//
function freezeDeliver(address _to, uint _amount, uint _freezeAmount, uint _freezeMonth, uint _unfreezeBeginTime) onlyOwner public {
require(owner != _to);
require(_freezeMonth > 0);
uint average = _freezeAmount / _freezeMonth;
BalanceInfo storage bi = balances[_to];
uint[] memory fa = new uint[](_freezeMonth);
uint[] memory rt = new uint[](_freezeMonth);
if(_amount < fnkSupply){
_amount = _amount * fnkEthRate;
average = average * fnkEthRate;
_freezeAmount = _freezeAmount * fnkEthRate;
}
require(balances[owner].balance > _amount);
uint remainAmount = _freezeAmount;
if(_unfreezeBeginTime == 0)
_unfreezeBeginTime = now + freezeDuration;
for(uint i=0;i<_freezeMonth-1;i++){
fa[i] = average;
rt[i] = _unfreezeBeginTime;
_unfreezeBeginTime += freezeDuration;
remainAmount = safeSub(remainAmount, average);
}
fa[i] = remainAmount;
rt[i] = _unfreezeBeginTime;
bi.balance = safeAdd(bi.balance, _amount);
bi.freezeAmount = fa;
bi.releaseTime = rt;
balances[owner].balance = safeSub(balances[owner].balance, _amount);
Transfer(owner, _to, _amount);
Freeze(_to, _freezeAmount);
}
function freezeDeliverMuti(address[] _addrs, uint _deliverAmount, uint _freezeAmount, uint _freezeMonth, uint _unfreezeBeginTime) onlyOwner public {
require(_addrs.length <= 255);
for(uint i=0;i< _addrs.length;i++){
freezeDeliver(_addrs[i], _deliverAmount, _freezeAmount, _freezeMonth, _unfreezeBeginTime);
}
}
function freezeDeliverMultiStandalone(address[] _addrs, uint[] _deliverAmounts, uint[] _freezeAmounts, uint _freezeMonth, uint _unfreezeBeginTime) onlyOwner public {
require(_addrs.length <= 255);
require(_addrs.length == _deliverAmounts.length);
require(_addrs.length == _freezeAmounts.length);
for(uint i=0;i< _addrs.length;i++){
freezeDeliver(_addrs[i], _deliverAmounts[i], _freezeAmounts[i], _freezeMonth, _unfreezeBeginTime);
}
}
// buy tokens directly
function () external payable {
buyTokens();
}
//
function buyTokens() payable isRunning isBuyable onlyWhitelist public {
uint256 weiVal = msg.value;
address investor = msg.sender;
require(investor != address(0) && weiVal >= minInvEth && weiVal <= maxInvEth);
require(safeAdd(weiVal,whitelistLimit[investor]) <= maxInvEth);
uint256 amount = 0;
if(now > sellDeadline1)
amount = safeMul(msg.value, ethFnkRate2);
else
amount = safeMul(msg.value, ethFnkRate1);
whitelistLimit[investor] = safeAdd(weiVal, whitelistLimit[investor]);
balances[owner].balance = safeSub(balances[owner].balance, amount);
balances[investor].balance = safeAdd(balances[investor].balance, amount);
Transfer(owner, investor, amount);
}
function addWhitelist(address[] _addrs) public onlyOwner {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
if (!whitelist[_addrs[i]]){
whitelist[_addrs[i]] = true;
}
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner].balance;
}
function freezeOf(address _owner) constant public returns (uint256) {
BalanceInfo storage bi = balances[_owner];
uint freezeAmount = 0;
uint t = now;
for(uint i=0;i< bi.freezeAmount.length;i++){
if(t < bi.releaseTime[i])
freezeAmount += bi.freezeAmount[i];
}
return freezeAmount;
}
function transfer(address _to, uint256 _amount) isRunning onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
uint freezeAmount = freezeOf(msg.sender);
uint256 _balance = safeSub(balances[msg.sender].balance, freezeAmount);
require(_amount <= _balance);
balances[msg.sender].balance = safeSub(balances[msg.sender].balance,_amount);
balances[_to].balance = safeAdd(balances[_to].balance,_amount);
Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) isRunning onlyPayloadSize(3 * 32) public returns (bool success) {
require(_from != address(0) && _to != address(0));
require(_amount <= allowed[_from][msg.sender]);
uint freezeAmount = freezeOf(_from);
uint256 _balance = safeSub(balances[_from].balance, freezeAmount);
require(_amount <= _balance);
balances[_from].balance = safeSub(balances[_from].balance,_amount);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_amount);
balances[_to].balance = safeAdd(balances[_to].balance,_amount);
Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) isRunning public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) {
return false;
}
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function withdraw() onlyOwner public {
require(this.balance > 0);
owner.transfer(this.balance);
Transfer(this, owner, this.balance);
}
function burn(address burner, uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender].balance);
balances[burner].balance = safeSub(balances[burner].balance, _value);
totalSupply = safeSub(totalSupply, _value);
fnkSupply = totalSupply / fnkEthRate;
Burn(burner, _value);
}
function mint(address _target, uint256 _amount) onlyOwner public {
if(_target == address(0))
_target = owner;
balances[_target].balance = safeAdd(balances[_target].balance, _amount);
totalSupply = safeAdd(totalSupply,_amount);
fnkSupply = totalSupply / fnkEthRate;
Transfer(0, this, _amount);
Transfer(this, _target, _amount);
}
}
| 220,893 | 827 |
dfcba57d1831adb673ce27f6388e3092e743ff0d7fd8b479750ee3d775583ea7
| 19,842 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/77/7790c7af61296883E917E19cC847395f6CBA5742_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;
}
}
}
}
| 96,815 | 828 |
d96a551bd9ef72d77b8a3772f4965ab4dd950f1e8ae8a265daf92ae4e00f786d
| 12,244 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4295c72c58fdcd02b626c6453c6c29e217077211.sol
| 3,301 | 12,198 |
pragma solidity 0.4.24;
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract Lottery is Owned {
string constant version = "1.0.0";
address admin;
mapping (uint => Game) public games;
mapping (uint => mapping (address => Ticket[])) public tickets;
mapping (address => uint) public withdrawGameIndex;
mapping (address => uint) allowed;
uint public gameIndex;
uint public goldKeyJackpot;
uint public firstPrizeJackpot;
uint public bonusJackpot;
uint public nextPrice;
bool public buyEnable = true;
mapping(bytes32 => uint) keys;
uint currentMappingVersion;
struct Ticket {
address user;
uint[] numbers;
uint buyTime;
}
struct Game {
uint startTime;
uint price;
uint ticketIndex;
uint[] winNumbers;
uint goldKey;
uint blockIndex;
string blockHash;
uint averageBonus;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
function depositOwnership(address admin_) public onlyOwner {
require(admin_ != address(0));
admin = admin_;
}
constructor() public {
nextPrice = 0.01 ether;
games[0].price = nextPrice;
games[0].startTime = now;
}
function() public payable {
require(buyEnable);
require(address(this) != msg.sender);
require(msg.data.length > 9);
require(msg.data.length % 9 == 1);
Game storage game = games[gameIndex];
uint count = uint(msg.data[0]);
require(msg.value == count * game.price);
Ticket[] storage tickets_ = tickets[gameIndex][msg.sender];
uint goldCount = 0;
uint i = 1;
while(i < msg.data.length) {
uint[] memory number_ = new uint[](9);
for(uint j = 0; j < 9; j++) {
number_[j] = uint(msg.data[i++]);
}
goldCount += number_[1];
tickets_.push(Ticket(msg.sender, number_, now));
game.ticketIndex++;
}
if(goldCount > 0) {
uint goldKey_ = getKeys(msg.sender);
require(goldKey_ >= goldCount);
goldKey_ -= goldCount;
bytes32 key = keccak256(abi.encodePacked(currentMappingVersion, msg.sender));
keys[key] = goldKey_;
}
uint amount = msg.value * 4 / 10;
firstPrizeJackpot += amount;
bonusJackpot += amount;
goldKeyJackpot += amount;
if(goldKeyJackpot >= 1500 ether) {
game.goldKey++;
goldKeyJackpot -= 1500 ether;
}
emit LogBuyTicket(gameIndex, msg.sender, msg.data, firstPrizeJackpot, bonusJackpot);
}
function getWinNumbers(string blockHash) public pure returns (uint[]){
bytes32 random = keccak256(bytes(blockHash));
uint[] memory allRedNumbers = new uint[](40);
uint[] memory allBlueNumbers = new uint[](10);
uint[] memory winNumbers = new uint[](6);
for (uint i = 0; i < 40; i++) {
allRedNumbers[i] = i + 1;
if(i < 10) {
allBlueNumbers[i] = i;
}
}
for (i = 0; i < 5; i++) {
uint n = 40 - i;
uint r = (uint(random[i * 4]) + (uint(random[i * 4 + 1]) << 8) + (uint(random[i * 4 + 2]) << 16) + (uint(random[i * 4 + 3]) << 24)) % (n + 1);
winNumbers[i] = allRedNumbers[r];
allRedNumbers[r] = allRedNumbers[n - 1];
}
uint t = (uint(random[i * 4]) + (uint(random[i * 4 + 1]) << 8) + (uint(random[i * 4 + 2]) << 16) + (uint(random[i * 4 + 3]) << 24)) % 10;
winNumbers[5] = allBlueNumbers[t];
return winNumbers;
}
function getTicketsByGameIndex(uint gameIndex_) public view returns (uint[] tickets_){
Ticket[] storage ticketArray = tickets[gameIndex_][msg.sender];
tickets_ = new uint[](ticketArray.length * 12);
uint k;
for(uint i = 0; i < ticketArray.length; i++) {
Ticket storage ticket = ticketArray[i];
tickets_[k++] = i;
tickets_[k++] = ticket.buyTime;
tickets_[k++] = games[gameIndex_].price;
for (uint j = 0; j < 9; j++)
tickets_[k++] = ticket.numbers[j];
}
}
function getGameByIndex(uint _gameIndex, bool lately) public view returns (uint[] res){
if(lately) _gameIndex = gameIndex;
if(_gameIndex > gameIndex) return res;
res = new uint[](15);
Game storage game = games[_gameIndex];
uint k;
res[k++] = _gameIndex;
res[k++] = game.startTime;
res[k++] = game.price;
res[k++] = game.ticketIndex;
res[k++] = bonusJackpot;
res[k++] = firstPrizeJackpot;
res[k++] = game.blockIndex;
if (game.winNumbers.length == 0) {
for (uint j = 0; j < 6; j++)
res[k++] = 0;
} else {
for (j = 0; j < 6; j++)
res[k++] = game.winNumbers[j];
}
res[k++] = game.goldKey;
res[k++] = game.averageBonus;
}
// function getGames(uint offset, uint count) public view returns (uint[] res){
// if (offset > gameIndex) return res;
// uint k;
// uint n = offset + count;
// if (n > gameIndex + 1) n = gameIndex + 1;
// res = new uint[]((n - offset) * 15);
// for(uint i = offset; i < n; i++) {
// Game storage game = games[i];
// res[k++] = i;
// res[k++] = game.startTime;
// res[k++] = game.price;
// res[k++] = game.ticketIndex;
// res[k++] = bonusJackpot;
// res[k++] = firstPrizeJackpot;
// res[k++] = game.blockIndex;
// if (game.winNumbers.length == 0) {
// for (uint j = 0; j < 6; j++)
// res[k++] = 0;
// } else {
// for (j = 0; j < 6; j++)
// res[k++] = game.winNumbers[j];
// }
// res[k++] = game.goldKey;
// res[k++] = game.averageBonus;
// }
// }
function stopCurrentGame(uint blockIndex) public onlyOwner {
Game storage game = games[gameIndex];
buyEnable = false;
game.blockIndex = blockIndex;
emit LogStopCurrentGame(gameIndex, blockIndex);
}
function drawNumber(uint blockIndex, string blockHash) public onlyOwner returns (uint[] res){
Game storage game = games[gameIndex];
require(game.blockIndex > 0);
require(blockIndex > game.blockIndex);
game.blockIndex = blockIndex;
game.blockHash = blockHash;
game.winNumbers = getWinNumbers(blockHash);
emit LogDrawNumbers(gameIndex, blockIndex, blockHash, game.winNumbers);
res = game.winNumbers;
}
function drawReuslt(uint goldCount, address[] goldKeys, address[] jackpots, uint _jackpot, uint _bonus, uint _averageBonus) public onlyOwner {
firstPrizeJackpot -= _jackpot;
bonusJackpot -= _bonus;
Game storage game = games[gameIndex];
if(jackpots.length > 0 && _jackpot > 0) {
deleteAllReports();
uint amount = _jackpot / jackpots.length;
for(uint j = 0; j < jackpots.length; j++) {
allowed[jackpots[j]] += amount;
}
} else {
for(uint i = 0; i < goldKeys.length; i++) {
game.goldKey += goldCount;
rewardKey(goldKeys[i], 1);
}
}
game.averageBonus = _averageBonus;
emit LogDrawReuslt(gameIndex, goldCount, goldKeys, jackpots, _jackpot, _bonus, _averageBonus);
}
function getAllowed(address _address) public onlyOwner view returns(uint) {
return allowed[_address];
}
function withdraw() public payable {
uint amount = allowance();
require(amount >= 0.05 ether);
withdrawGameIndex[msg.sender] = gameIndex;
allowed[msg.sender] = 0;
msg.sender.transfer(amount);
emit LogTransfer(gameIndex, msg.sender, amount);
}
function allowance() public view returns (uint amount) {
uint gameIndex_ = withdrawGameIndex[msg.sender];
if(gameIndex_ == gameIndex) return amount;
require(gameIndex_ < gameIndex);
amount += allowed[msg.sender];
for(uint i = gameIndex_; i < gameIndex; i++) {
Game storage game = games[i];
Ticket[] storage tickets_ = tickets[i][msg.sender];
for(uint j = 0; j < tickets_.length; j++) {
Ticket storage ticket = tickets_[j];
if(game.winNumbers[5] != ticket.numbers[8]) {
amount += game.averageBonus * ticket.numbers[2];
}
}
}
}
function startNextGame() public onlyOwner {
buyEnable = true;
gameIndex++;
games[gameIndex].startTime = now;
games[gameIndex].price = nextPrice;
emit LogStartNextGame(gameIndex);
}
function addJackpotGuaranteed(uint addJackpot) public onlyOwner {
firstPrizeJackpot += addJackpot;
}
function rewardKey(address _user, uint gold) public onlyOwner {
uint goldKey = getKeys(_user);
goldKey += gold;
setKeys(_user, goldKey);
emit LogRewardKey(_user, gold);
}
function getKeys(address _key) public view returns(uint) {
bytes32 key = keccak256(abi.encodePacked(currentMappingVersion, _key));
return keys[key];
}
function setKeys(address _key, uint _value) private onlyOwner {
bytes32 key = keccak256(abi.encodePacked(currentMappingVersion, _key));
keys[key] = _value;
}
function deleteAllReports() public onlyOwner {
Game storage game = games[gameIndex];
game.goldKey = 0;
currentMappingVersion++;
emit LogDeleteAllReports(gameIndex, currentMappingVersion);
}
function killContract() public onlyOwner {
selfdestruct(msg.sender);
emit LogKillContract(msg.sender);
}
function setPrice(uint price) public onlyOwner {
nextPrice = price;
emit LogSetPrice(price);
}
function setBuyEnable(bool _buyEnable) public onlyOwner {
buyEnable = _buyEnable;
emit LogSetBuyEnable(msg.sender, _buyEnable);
}
function adjustPrizePoolAfterWin(uint _jackpot, uint _bonus) public onlyOwner {
firstPrizeJackpot -= _jackpot;
bonusJackpot -= _bonus;
emit LogAdjustPrizePoolAfterWin(gameIndex, _jackpot, _bonus);
}
function transferToOwner(uint bonus) public payable onlyOwner {
msg.sender.transfer(bonus);
emit LogTransfer(gameIndex, msg.sender, bonus);
}
event LogBuyTicket(uint indexed _gameIndex, address indexed from, bytes numbers, uint _firstPrizeJackpot, uint _bonusJackpot);
event LogRewardKey(address indexed _user, uint _gold);
event LogAwardWinner(address indexed _user, uint[] _winner);
event LogStopCurrentGame(uint indexed _gameIndex, uint indexed _blockIndex);
event LogDrawNumbers(uint indexed _gameIndex, uint indexed _blockIndex, string _blockHash, uint[] _winNumbers);
event LogStartNextGame(uint indexed _gameIndex);
event LogDeleteAllReports(uint indexed _gameIndex, uint _currentMappingVersion);
event LogKillContract(address indexed _owner);
event LogSetPrice(uint indexed _price);
event LogSetBuyEnable(address indexed _owner, bool _buyEnable);
event LogTransfer(uint indexed _gameIndex, address indexed from, uint value);
event LogApproval(address indexed _owner, address indexed _spender, uint256 _value);
event LogAdjustPrizePoolAfterWin(uint indexed _gameIndex, uint _jackpot, uint _bonus);
event LogDrawReuslt(uint indexed _gameIndex, uint _goldCount, address[] _goldKeys, address[] _jackpots, uint _jackpot, uint _bonus, uint _averageBonus);
}
| 208,332 | 829 |
2fee124b55542c95bf44c58d82c96d07993c8a66c816bc9d660daeaf0bc5c3ea
| 28,881 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSyDW6wMoEMrJvDSDhf9iS3wuKice6JUzr_BurnMiningNew.sol
| 5,197 | 19,275 |
//SourceUnit: BurnMiningTest.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view 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 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 add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address _to, uint256 _amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IOracle {
function consultAveragePrice(address token, uint256 interval) external view returns (uint256);
}
// txToken: 0x7BACABB0B39C29B890CD9DB2DF9F9450972B7B89
// genesisUser: 0xB3DDBE2A15E722D56FEC480AABB65AD15BE053FE
// Lands: 0xD46C1BB0410EDDEC4E11BA7C8AAF2C73B3A322A6
contract BurnMiningNew is Ownable {
using SafeMath for uint256;
enum Level { BORN, PEOPLE, LAND, SKY }
// token24h
event BurnAddPower(address user, uint256 value, uint256 tokenValue, uint256 burnedToUSDT, uint256 burnPower, uint256 price, address referrer);
//
event Registration(address user, address referer);
//
event ChangeLevel(address user, Level oldLevel, Level newLevel);
//
event StartSettling(uint256 blockNum, uint256 price);
//
event EndSettling(uint256 blockNum);
// tokentoken
event DistributeReward(address user, uint256 costBurnedToUSDT, uint256 costBurnedToPower, uint256 rewardNum, uint256 newRewardNum, uint256 poolReward, uint256 rankReward, uint256 publicityReward, uint256 teamReward);
//
event ClaimReward(address user, uint256 userReward);
//
event ClaimPoolReward(address user, uint256 reward);
//
event ClaimPublicityReward(address user, uint256 reward);
//
event ClaimTeamReward(address user, uint256 reward);
struct UserInfo {
//
address user;
//
bool isExisted;
// id
uint256 id;
//
uint256 lastBurnedTimestamp;
// U
uint256 burnedToUSDT;
// U= +
uint256 mintTokenPower;
// U
uint256 lastBurnedValue;
//
address referrer;
//
Level level;
// Token
uint256 pendingReward;
}
// ************************ Config ************************
//
uint256 public epochAmount;
//
uint256 public miningMultiple = 3;
//
uint256 public powerMultiple = 2;
// Oracle
IOracle public oracle;
// txToken
IERC20 public txToken;
//
address public genesisUser;
// token
uint256 public pendingPoolReward;
//
address public feeToPool;
// token
uint256 public pendingPublicityReward;
//
address public feeToPublicity;
//
uint256 public pendingTeamReward;
//
address public feeToTeam;
//
uint256 public pendingRankReward;
// ************************ State ************************
//
uint256 public totalPower;
//
address[] public allUser;
//
bool public isSettling;
//
uint256 public settlingPrice;
//
uint256 public lastBlockNum;
//
uint256 public burnedInterval = 24 hours;
//
mapping(address => UserInfo) public addressUserInfo;
// id => address
mapping(uint256 => address) public userIdAddress;
// =>
mapping(Level => uint256) public levelMultiple;
modifier running() {
require(!isSettling, "BurnMing: IS_SETTLING");
_;
}
modifier settling() {
require(isSettling, "BurnMing: IS_RUNNING");
_;
}
constructor(IERC20 _txToken,
IOracle _oracle,
address _genesisUser) public {
require(address(_txToken) != address(0), "BurnMing: TOKEN_ZERO_ADDRESS");
require(address(_oracle) != address(0), "BurnMing: ORACLE_ZERO_ADDRESS");
require(address(_genesisUser) != address(0), "BurnMing: FIRST_USER_ZERO_ADDRESS");
txToken = _txToken;
oracle = _oracle;
genesisUser = _genesisUser;
//
UserInfo storage userInfo = addressUserInfo[_genesisUser];
userInfo.user = _genesisUser;
userInfo.isExisted = true;
userInfo.level = Level.BORN;
userInfo.id = allUser.length;
userIdAddress[userInfo.id] = genesisUser;
allUser.push(genesisUser);
// 2/3/5/10
levelMultiple[Level.BORN] = uint256(2);
levelMultiple[Level.PEOPLE] = uint256(3);
levelMultiple[Level.LAND] = uint256(5);
levelMultiple[Level.SKY] = uint256(10);
//
lastBlockNum = block.number;
}
function getTokenAveragePrice() public pure returns (uint256) {
// uint256 price = oracle.consultAveragePrice(address(txToken), 24 hours);
uint256 price = 500000;
return price;
}
//
function _register(address _referrer) internal returns (bool success) {
if (msg.sender == genesisUser) {
return true;
}
// 0
require(_referrer != address(0), "BurnMingZERO_ADDRESS");
//
require(msg.sender != _referrer, "BurnMingCALLER_NOT_SAME_AS_REFERER");
//
UserInfo storage refererInfo = addressUserInfo[_referrer];
//
UserInfo storage userInfo = addressUserInfo[msg.sender];
//
require(refererInfo.isExisted, "BurnMingREFERER_NOT_REGISTRATION");
//
if(!userInfo.isExisted) {
userInfo.user = msg.sender;
//
userInfo.isExisted = true;
//
userInfo.referrer = _referrer;
//
userInfo.level = Level.BORN;
// id0
userInfo.id = allUser.length;
// id
userIdAddress[userInfo.id] = msg.sender;
//
allUser.push(msg.sender);
//
emit Registration(msg.sender, _referrer);
}
return true;
}
function _burnAddPower(UserInfo storage userInfo, uint256 _value) internal returns(uint256, uint256) {
//
require(_value > userInfo.lastBurnedValue, "BurnMing: BURN_MUST_BE_BIGGER_THEN_LAST");
//
require(block.timestamp.sub(burnedInterval) >= userInfo.lastBurnedTimestamp, "BurnMing: MUST_BIGGER_THEN_INTERVAL");
//
userInfo.lastBurnedValue = _value;
//
userInfo.lastBurnedTimestamp = block.timestamp;
// = * (3)
uint256 _burnedToUSDT = _value.mul(miningMultiple);
// +=
userInfo.burnedToUSDT = userInfo.burnedToUSDT.add(_burnedToUSDT);
// = * (2)
uint256 _burnPower = _value.mul(powerMultiple);
// +=
userInfo.mintTokenPower = userInfo.mintTokenPower.add(_burnPower);
//
totalPower = totalPower.add(_burnPower);
return (_burnedToUSDT, _burnPower);
}
function _updateRefererPower(UserInfo storage refererInfo,
uint256 _value) internal returns(uint256) {
//
uint256 refererAddedPower = _value.mul(levelMultiple[refererInfo.level]) > refererInfo.burnedToUSDT ?
refererInfo.burnedToUSDT: _value.mul(levelMultiple[refererInfo.level]);
// +=
refererInfo.mintTokenPower = refererInfo.mintTokenPower.add(refererAddedPower);
//
totalPower = totalPower.add(refererAddedPower);
return refererAddedPower;
}
function canBurn(address user) public view returns(bool) {
//
UserInfo storage userInfo = addressUserInfo[user];
require(userInfo.isExisted, "BurnMing: NOT_REGISTER");
//
if (block.timestamp.sub(burnedInterval) >= userInfo.lastBurnedTimestamp) {
return true;
} else {
return false;
}
}
function burn(uint256 _value, address _referer) public running returns (bool success) {
// 100u
require(_value > 100 * 1e6, "BurnMing: VALUE_MUST_BE_BIGGER_THEN_ONE_HUNDRED");
// 1
_register(_referer);
// 2token
//
uint256 price = getTokenAveragePrice();
// token
uint256 tokenValue = _value.mul(1e20).div(price).div(1e12);
//
require(txToken.balanceOf(msg.sender) >= tokenValue, "BurnMing: INSUFFICIENT_BALANCE");
//
txToken.transferFrom(msg.sender, address(this), tokenValue);
// 3token
UserInfo storage userInfo = addressUserInfo[msg.sender];
(uint256 burnedToUSDT, uint256 burnPower) = _burnAddPower(userInfo, _value);
//
if(msg.sender != genesisUser) {
UserInfo storage refererInfo = addressUserInfo[userInfo.referrer];
// 4
_updateRefererPower(refererInfo, _value);
}
// 5
emit BurnAddPower(msg.sender, _value, tokenValue, burnedToUSDT, burnPower, price, userInfo.referrer);
return true;
}
function claimReward() public running {
//
UserInfo storage userInfo = addressUserInfo[msg.sender];
require(userInfo.isExisted, "BurnMing: NOT_REGISTER");
//
uint256 rewardNum = userInfo.pendingReward;
require(rewardNum > uint256(0), "BurnMing: ZERO_REWARD");
//
userInfo.pendingReward = 0;
//
txToken.transfer(msg.sender, rewardNum);
//
emit ClaimReward(msg.sender, rewardNum);
}
function claimFeeReward() public running {
if (msg.sender == feeToPool) {
txToken.transfer(msg.sender, pendingPoolReward);
emit ClaimPoolReward(msg.sender, pendingPoolReward);
pendingPoolReward = 0;
} else if (msg.sender == feeToTeam) {
txToken.transfer(msg.sender, pendingTeamReward);
emit ClaimTeamReward(msg.sender, pendingTeamReward);
pendingTeamReward = 0;
} else if (msg.sender == feeToPublicity) {
txToken.transfer(msg.sender, pendingPublicityReward);
emit ClaimPublicityReward(msg.sender, pendingPublicityReward);
pendingPublicityReward = 0;
}
}
function multiTransferRanking(address[] memory users, uint256[] memory rewards) public running onlyOwner {
require(users.length == rewards.length, "BurnMing: NOT_SAME");
uint256 _pendingRankReward = pendingRankReward;
for(uint256 i; i < users.length; i++) {
txToken.transfer(users[i], rewards[i]);
_pendingRankReward = _pendingRankReward.sub(rewards[i]);
}
pendingRankReward = _pendingRankReward;
}
// ****************** Owner ******************
function changeLevel(address user, Level newLevel) public onlyOwner {
require(levelMultiple[newLevel] > uint256(0), "BurnMing: LEVEL_NOT_EXIST");
//
UserInfo storage userInfo = addressUserInfo[user];
require(userInfo.isExisted, "BurnMing: NOT_REGISTER");
//
Level oldLevel = userInfo.level;
userInfo.level = newLevel;
emit ChangeLevel(user, oldLevel, newLevel);
}
function setSettling(bool _isSettling) public onlyOwner {
if(isSettling != _isSettling) {
isSettling = _isSettling;
// 24h
if(_isSettling) {
// 24h
uint256 _price = getTokenAveragePrice();
//
settlingPrice = _price;
emit StartSettling(block.number, _price);
} else {
//
lastBlockNum = block.number;
emit EndSettling(block.number);
}
}
}
function _distributeFeeReward(uint256 rewardNum) internal returns(uint256, uint256, uint256, uint256, uint256) {
//
uint256 poolReward = rewardNum.mul(30).div(1000);
//
uint256 rankReward = rewardNum.mul(12).div(1000);
//
uint256 publicityReward = rewardNum.mul(6).div(1000);
//
uint256 teamReward = rewardNum.mul(2).div(1000);
pendingPoolReward = pendingPoolReward.add(poolReward);
pendingRankReward = pendingRankReward.add(rankReward);
pendingPublicityReward = pendingPublicityReward.add(publicityReward);
pendingTeamReward = pendingTeamReward.add(teamReward);
// avoid stack too deep
rewardNum = rewardNum.sub(poolReward);
rewardNum = rewardNum.sub(rankReward);
rewardNum = rewardNum.sub(publicityReward);
rewardNum = rewardNum.sub(teamReward);
return (rewardNum, poolReward, rankReward, publicityReward, teamReward);
}
// U
function distributeReward(address user, uint256 costBurnedToUSDT, uint256 costBurnedToPower, uint256 rewardNum) public settling onlyOwner {
//
UserInfo storage userInfo = addressUserInfo[user];
require(userInfo.isExisted, "BurnMing: NOT_REGISTER");
//
if(costBurnedToUSDT > userInfo.burnedToUSDT){
costBurnedToUSDT = userInfo.burnedToUSDT;
}
//
userInfo.burnedToUSDT = userInfo.burnedToUSDT.sub(costBurnedToUSDT);
//
userInfo.mintTokenPower = userInfo.mintTokenPower.sub(costBurnedToPower);
(uint256 newRewardNum, uint256 poolReward, uint256 rankReward, uint256 publicityReward, uint256 teamReward) = _distributeFeeReward(rewardNum);
// token
userInfo.pendingReward = userInfo.pendingReward.add(newRewardNum);
//
totalPower = totalPower.sub(costBurnedToPower);
emit DistributeReward(user, costBurnedToUSDT, costBurnedToPower, rewardNum, newRewardNum, poolReward, rankReward, publicityReward, teamReward);
}
//
function setLevelMultiple(Level level, uint256 multiple) public onlyOwner {
require(multiple > uint256(0), "BurnMing: MULTIPLE_MUST_BE_BIGGER_THEN_ZERO");
levelMultiple[level] = multiple;
}
// oracle
function setOracle(IOracle _oracle) public onlyOwner {
require(address(_oracle) != address(0), "BurnMing: ZERO_ADDRESS");
oracle = _oracle;
}
// TxToken
function setTxToken(IERC20 _txToken) public onlyOwner {
require(address(_txToken) != address(0), "BurnMing: ZERO_ADDRESS");
txToken = _txToken;
}
//
function setFeeToPool(address _feeToPool) public onlyOwner {
require(_feeToPool != address(0), "BurnMing: ZERO_ADDRESS");
feeToPool = _feeToPool;
}
//
function setFeeToPublicity(address _feeToPublicity) public onlyOwner {
require(_feeToPublicity != address(0), "BurnMing: ZERO_ADDRESS");
feeToPublicity = _feeToPublicity;
}
//
function setFeeToTeam(address _feeToTeam) public onlyOwner {
require(_feeToTeam != address(0), "BurnMing: ZERO_ADDRESS");
feeToTeam = _feeToTeam;
}
//
function setEpochAmount(uint256 _epochAmount) public onlyOwner {
require(_epochAmount > uint256(0), "BurnMing: AMOUNT_MUST_BE_BIGGER_THEN_ZERO");
epochAmount = _epochAmount;
}
//
function setMiningMultiple(uint256 _miningMultiple) public onlyOwner {
require(_miningMultiple > uint256(0), "BurnMing: MULTIPLE_MUST_BE_BIGGER_THEN_ZERO");
miningMultiple = _miningMultiple;
}
//
function setPowerMultiple(uint256 _powerMultiple) public onlyOwner {
require(_powerMultiple > uint256(0), "BurnMing: POWER_MULTIPLE_MUST_BE_BIGGER_THEN_ZERO");
powerMultiple = _powerMultiple;
}
//
function setBurnedInterval(uint256 _burnedInterval) public onlyOwner {
burnedInterval = _burnedInterval;
}
//
function emergencyWithdraw(address _token) public onlyOwner {
require(IERC20(_token).balanceOf(address(this)) > 0, "BurnMing: INSUFFICIENT_BALANCE");
IERC20(_token).transfer(msg.sender, IERC20(_token).balanceOf(address(this)));
}
}
| 286,054 | 830 |
5cd4636b08990af90f5c4617c2d34a825494b3872183acd205408895ca991d66
| 18,598 |
.sol
|
Solidity
| false |
281870469
|
yearn/audit
|
e3d76c568dad06d27c71d596e529f4764a36cb76
|
contracts/yBorrow/yCollateralVaultProxy.sol
| 4,575 | 18,313 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.10;
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract ReentrancyGuard {
uint private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
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) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
function mod(uint a, uint b) internal pure returns (uint) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
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, uint 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, uint value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint 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, uint 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 uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint value) internal {
uint newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint value) internal {
uint 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");
}
}
}
interface Aave {
function borrow(address _reserve, uint _amount, uint _interestRateModel, uint16 _referralCode) external;
function setUserUseReserveAsCollateral(address _reserve, bool _useAsCollateral) external;
function repay(address _reserve, uint _amount, address payable _onBehalfOf) external payable;
function getUserAccountData(address _user)
external
view
returns (uint totalLiquidityETH,
uint totalCollateralETH,
uint totalBorrowsETH,
uint totalFeesETH,
uint availableBorrowsETH,
uint currentLiquidationThreshold,
uint ltv,
uint healthFactor);
}
interface AaveToken {
function underlyingAssetAddress() external returns (address);
}
interface Oracle {
function getAssetPrice(address reserve) external view returns (uint);
function latestAnswer() external view returns (uint);
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
function getLendingPoolCore() external view returns (address);
function getPriceOracle() external view returns (address);
}
contract iCollateralVault is ReentrancyGuard {
using SafeERC20 for IERC20;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
uint public model = 2;
address public asset = address(0);
address private _owner;
address[] private _activeReserves;
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "!owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
constructor() public {
_owner = msg.sender;
}
function setModel(uint _model) public onlyOwner {
model = _model;
}
function setBorrow(address _asset) public onlyOwner {
asset = _asset;
}
function getReserves() public view returns (address[] memory) {
return _activeReserves;
}
// LP deposit, anyone can deposit/topup
function activate(address reserve) external {
_activeReserves.push(reserve);
Aave(getAave()).setUserUseReserveAsCollateral(reserve, true);
}
// No logic, logic handled underneath by Aave
function withdraw(address reserve, uint amount, address to) external onlyOwner {
IERC20(reserve).safeTransfer(to, amount);
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool();
}
function getAaveCore() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPoolCore();
}
// amount needs to be normalized
function borrow(address reserve, uint amount, address to) external nonReentrant onlyOwner {
require(asset == reserve || asset == address(0), "reserve not available");
// LTV logic handled by underlying
Aave(getAave()).borrow(reserve, amount, model, 7);
IERC20(reserve).safeTransfer(to, amount);
}
function repay(address reserve, uint amount) external nonReentrant onlyOwner {
// Required for certain stable coins (USDT for example)
IERC20(reserve).approve(address(getAaveCore()), 0);
IERC20(reserve).approve(address(getAaveCore()), amount);
Aave(getAave()).repay(reserve, amount, address(uint160(address(this))));
}
}
contract iCollateralVaultProxy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint;
mapping (address => address[]) private _ownedVaults;
mapping (address => address) private _vaults;
// Spending limits per user measured in dollars 1e8
mapping (address => mapping (address => uint)) private _limits;
mapping (address => mapping (address => bool)) private _borrowerContains;
mapping (address => address[]) private _borrowers;
mapping (address => address[]) private _borrowerVaults;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
address public constant link = address(0xF79D6aFBb6dA890132F9D7c355e3015f15F3406F);
event IncreaseLimit(address indexed vault, address indexed owner, address indexed spender, uint limit);
event DecreaseLimit(address indexed vault, address indexed owner, address indexed spender, uint limit);
event SetModel(address indexed vault, address indexed owner, uint model);
event SetBorrow(address indexed vault, address indexed owner, address indexed reserve);
event Deposit(address indexed vault, address indexed owner, address indexed reserve, uint amount);
event Withdraw(address indexed vault, address indexed owner, address indexed reserve, uint amount);
event Borrow(address indexed vault, address indexed owner, address indexed reserve, uint amount);
event Repay(address indexed vault, address indexed owner, address indexed reserve, uint amount);
event DeployVault(address indexed vault, address indexed owner);
constructor() public {
}
function limit(address vault, address spender) public view returns (uint) {
return _limits[vault][spender];
}
function borrowers(address vault) public view returns (address[] memory) {
return _borrowers[vault];
}
function borrowerVaults(address spender) public view returns (address[] memory) {
return _borrowerVaults[spender];
}
function increaseLimit(address vault, address spender, uint addedValue) public {
require(isVaultOwner(address(vault), msg.sender), "!owner");
if (!_borrowerContains[vault][spender]) {
_borrowerContains[vault][spender] = true;
_borrowers[vault].push(spender);
_borrowerVaults[spender].push(vault);
}
uint amount = _limits[vault][spender].add(addedValue);
_approve(vault, spender, amount);
emit IncreaseLimit(vault, msg.sender, spender, amount);
}
function decreaseLimit(address vault, address spender, uint subtractedValue) public {
require(isVaultOwner(address(vault), msg.sender), "!owner");
uint amount = _limits[vault][spender].sub(subtractedValue, "<0");
_approve(vault, spender, amount);
emit DecreaseLimit(vault, msg.sender, spender, amount);
}
function setModel(iCollateralVault vault, uint model) public {
require(isVaultOwner(address(vault), msg.sender), "!owner");
vault.setModel(model);
emit SetModel(address(vault), msg.sender, model);
}
function setBorrow(iCollateralVault vault, address borrow) public {
require(isVaultOwner(address(vault), msg.sender), "!owner");
vault.setBorrow(borrow);
emit SetBorrow(address(vault), msg.sender, borrow);
}
function _approve(address vault, address spender, uint amount) internal {
require(spender != address(0), "address(0)");
_limits[vault][spender] = amount;
}
function isVaultOwner(address vault, address owner) public view returns (bool) {
return _vaults[vault] == owner;
}
function isVault(address vault) public view returns (bool) {
return _vaults[vault] != address(0);
}
// LP deposit, anyone can deposit/topup
function deposit(iCollateralVault vault, address aToken, uint amount) external {
require(isVault(address(vault)), "!vault");
IERC20(aToken).safeTransferFrom(msg.sender, address(vault), amount);
vault.activate(AaveToken(aToken).underlyingAssetAddress());
emit Deposit(address(vault), msg.sender, aToken, amount);
}
// No logic, handled underneath by Aave
function withdraw(iCollateralVault vault, address aToken, uint amount) external {
require(isVaultOwner(address(vault), msg.sender), "!owner");
vault.withdraw(aToken, amount, msg.sender);
emit Withdraw(address(vault), msg.sender, aToken, amount);
}
// amount needs to be normalized
function borrow(iCollateralVault vault, address reserve, uint amount) external {
uint _borrow = amount;
if (vault.asset() == address(0)) {
_borrow = getReservePriceUSD(reserve).mul(amount);
}
_approve(address(vault), msg.sender, _limits[address(vault)][msg.sender].sub(_borrow, "borrow amount exceeds allowance"));
vault.borrow(reserve, amount, msg.sender);
emit Borrow(address(vault), msg.sender, reserve, amount);
}
function repay(iCollateralVault vault, address reserve, uint amount) public {
require(isVault(address(vault)), "not a vault");
IERC20(reserve).safeTransferFrom(msg.sender, address(vault), amount);
vault.repay(reserve, amount);
emit Repay(address(vault), msg.sender, reserve, amount);
}
function getVaults(address owner) external view returns (address[] memory) {
return _ownedVaults[owner];
}
function deployVault() public returns (address) {
address vault = address(new iCollateralVault());
// Mark address as vault
_vaults[vault] = msg.sender;
// Set vault owner
address[] storage owned = _ownedVaults[msg.sender];
owned.push(vault);
_ownedVaults[msg.sender] = owned;
emit DeployVault(vault, msg.sender);
return vault;
}
function getVaultAccountData(address _vault)
external
view
returns (uint totalLiquidityUSD,
uint totalCollateralUSD,
uint totalBorrowsUSD,
uint totalFeesUSD,
uint availableBorrowsUSD,
uint currentLiquidationThreshold,
uint ltv,
uint healthFactor) {
(totalLiquidityUSD,
totalCollateralUSD,
totalBorrowsUSD,
totalFeesUSD,
availableBorrowsUSD,
currentLiquidationThreshold,
ltv,
healthFactor) = Aave(getAave()).getUserAccountData(_vault);
uint ETH2USD = getETHPriceUSD();
totalLiquidityUSD = totalLiquidityUSD.mul(ETH2USD);
totalCollateralUSD = totalCollateralUSD.mul(ETH2USD);
totalBorrowsUSD = totalBorrowsUSD.mul(ETH2USD);
totalFeesUSD = totalFeesUSD.mul(ETH2USD);
availableBorrowsUSD = availableBorrowsUSD.mul(ETH2USD);
}
function getAaveOracle() public view returns (address) {
return LendingPoolAddressesProvider(aave).getPriceOracle();
}
function getReservePriceETH(address reserve) public view returns (uint) {
return Oracle(getAaveOracle()).getAssetPrice(reserve);
}
function getReservePriceUSD(address reserve) public view returns (uint) {
return getReservePriceETH(reserve).mul(Oracle(link).latestAnswer()).div(1e26);
}
function getETHPriceUSD() public view returns (uint) {
return Oracle(link).latestAnswer();
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool();
}
}
| 233,020 | 831 |
1f1eacb99c5300050a5f4f66096b820583f04ddf60a15b281874f532cba6b09e
| 12,800 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8bca9dada921a9b848e1bc12a3668f8121e75e4c.sol
| 2,878 | 10,899 |
pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : dave@akomba.com
// released under Apache 2.0 licence
// input D:\Repositories\GitHub\Cronos\src\CRS.Presale.Contract\contracts\Presale.sol
// flattened : Friday, 28-Dec-18 10:47:36 UTC
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 ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor() internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
contract 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 Presale is Ownable, ReentrancyGuard {
using SafeMath for uint256;
struct ReferralData {
uint256 referrals; // number of referrals
uint256 bonusSum;
address[] children; // child referrals
}
uint256 public currentPrice = 0;
bool public isActive = false;
uint256 public currentDiscountSum = 0; // current sum of all discounts (have to stay in the contract for payout)
uint256 public overallDiscountSum = 0; // sum of all discounts given since beginning
bool public referralsEnabled = true; // are referrals enabled in general
mapping(address => uint) private referralBonuses;
uint256 public referralBonusMaxDepth = 3; // used to ensure the max depth
mapping(uint256 => uint) public currentReferralCommissionPercentages; // commission levels
uint256 public currentReferralBuyerDiscountPercentage = 5; // discount percentage if a buyer uses a valid affiliate link
mapping(address => address) private parentReferrals; // parent relationship
mapping(address => ReferralData) private referralData; // referral data for this address
mapping(address => uint) private nodesBought; // number of bought nodes
mapping(address => bool) private manuallyAddedReferrals; // we need a chance to add referrals manually since this is needed for promotion
event MasternodeSold(address buyer, uint256 price, string coinsTargetAddress, bool referral);
event MasternodePriceChanged(uint256 price);
event ReferralAdded(address buyer, address parent);
constructor() public {
currentReferralCommissionPercentages[0] = 10;
currentReferralCommissionPercentages[1] = 5;
currentReferralCommissionPercentages[2] = 3;
}
function () external payable {
// nothing to do
}
function buyMasternode(string memory coinsTargetAddress) public nonReentrant payable {
_buyMasternode(coinsTargetAddress, false, owner());
}
function buyMasternodeReferral(string memory coinsTargetAddress, address referral) public nonReentrant payable {
_buyMasternode(coinsTargetAddress, referralsEnabled, referral);
}
function _buyMasternode(string memory coinsTargetAddress, bool useReferral, address referral) internal {
require(isActive, "Buying is currently deactivated.");
require(currentPrice > 0, "There was no MN price set so far.");
uint256 nodePrice = currentPrice;
// nodes can be bought cheaper if the user uses a valid referral address
if (useReferral && isValidReferralAddress(referral)) {
nodePrice = getDiscountedNodePrice();
}
require(msg.value >= nodePrice, "Sent amount of ETH was too low.");
// check target address
uint256 length = bytes(coinsTargetAddress).length;
require(length >= 30 && length <= 42 , "Coins target address invalid");
if (useReferral && isValidReferralAddress(referral)) {
require(msg.sender != referral, "You can't be your own referral.");
// set parent/child relations (only if there is no connection/parent yet available)
// --> this also means that a referral structure can't be changed
address parent = parentReferrals[msg.sender];
if (referralData[parent].referrals == 0) {
referralData[referral].referrals = referralData[referral].referrals.add(1);
referralData[referral].children.push(msg.sender);
parentReferrals[msg.sender] = referral;
}
// iterate over commissionLevels and calculate commissions
uint256 discountSumForThisPayment = 0;
address currentReferral = referral;
for (uint256 level=0; level < referralBonusMaxDepth; level++) {
// only apply discount if referral address is valid (or as long we can step up the hierarchy)
if(isValidReferralAddress(currentReferral)) {
require(msg.sender != currentReferral, "Invalid referral structure (you can't be in your own tree)");
// do not take node price here since it could be already dicounted
uint256 referralBonus = currentPrice.div(100).mul(currentReferralCommissionPercentages[level]);
// set payout bonus
referralBonuses[currentReferral] = referralBonuses[currentReferral].add(referralBonus);
// set stats/counters
referralData[currentReferral].bonusSum = referralData[currentReferral].bonusSum.add(referralBonus);
discountSumForThisPayment = discountSumForThisPayment.add(referralBonus);
// step up one hierarchy level
currentReferral = parentReferrals[currentReferral];
} else {
// we can't find any parent - stop hierarchy calculation
break;
}
}
require(discountSumForThisPayment < nodePrice, "Wrong calculation of bonuses/discounts - would be higher than the price itself");
currentDiscountSum = currentDiscountSum.add(discountSumForThisPayment);
overallDiscountSum = overallDiscountSum.add(discountSumForThisPayment);
}
// set the node bought counter
nodesBought[msg.sender] = nodesBought[msg.sender].add(1);
emit MasternodeSold(msg.sender, currentPrice, coinsTargetAddress, useReferral);
}
function setActiveState(bool active) public onlyOwner {
isActive = active;
}
function setPrice(uint256 price) public onlyOwner {
require(price > 0, "Price has to be greater than zero.");
currentPrice = price;
emit MasternodePriceChanged(price);
}
function setReferralsEnabledState(bool _referralsEnabled) public onlyOwner {
referralsEnabled = _referralsEnabled;
}
function setReferralCommissionPercentageLevel(uint256 level, uint256 percentage) public onlyOwner {
require(percentage >= 0 && percentage <= 20, "Percentage has to be between 0 and 20.");
require(level >= 0 && level < referralBonusMaxDepth, "Invalid depth level");
currentReferralCommissionPercentages[level] = percentage;
}
function setReferralBonusMaxDepth(uint256 depth) public onlyOwner {
require(depth >= 0 && depth <= 10, "Referral bonus depth too high.");
referralBonusMaxDepth = depth;
}
function setReferralBuyerDiscountPercentage(uint256 percentage) public onlyOwner {
require(percentage >= 0 && percentage <= 20, "Percentage has to be between 0 and 20.");
currentReferralBuyerDiscountPercentage = percentage;
}
function addReferralAddress(address addr) public onlyOwner {
manuallyAddedReferrals[addr] = true;
}
function removeReferralAddress(address addr) public onlyOwner {
manuallyAddedReferrals[addr] = false;
}
function withdraw(uint256 amount) public onlyOwner {
owner().transfer(amount);
}
function withdrawReferralBonus() public nonReentrant returns (bool) {
uint256 amount = referralBonuses[msg.sender];
if (amount > 0) {
referralBonuses[msg.sender] = 0;
currentDiscountSum = currentDiscountSum.sub(amount);
if (!msg.sender.send(amount)) {
referralBonuses[msg.sender] = amount;
currentDiscountSum = currentDiscountSum.add(amount);
return false;
}
}
return true;
}
function checkReferralBonusHeight(address addr) public view returns (uint) {
return referralBonuses[addr];
}
function getNrOfReferrals(address addr) public view returns (uint) {
return referralData[addr].referrals;
}
function getReferralBonusSum(address addr) public view returns (uint) {
return referralData[addr].bonusSum;
}
function getReferralChildren(address addr) public view returns (address[] memory) {
return referralData[addr].children;
}
function getReferralChild(address addr, uint256 idx) public view returns (address) {
return referralData[addr].children[idx];
}
function isValidReferralAddress(address addr) public view returns (bool) {
return nodesBought[addr] > 0 || manuallyAddedReferrals[addr] == true;
}
function getNodesBoughtCountForAddress(address addr) public view returns (uint256) {
return nodesBought[addr];
}
function getDiscountedNodePrice() public view returns (uint256) {
return currentPrice.sub(currentPrice.div(100).mul(currentReferralBuyerDiscountPercentage));
}
}
| 217,331 | 832 |
49a0c946d891c4f08bc99d0a280d1420ec4dffb525011d6e73c8e8d4f5634e29
| 37,419 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa3b7f0e143c62c260ce6d0f9c6b2d6dfd33c735d.sol
| 5,632 | 21,671 |
pragma solidity 0.4.24;
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;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Escrow is Ownable {
using SafeMath for uint256;
event Deposited(address indexed payee, uint256 weiAmount);
event Withdrawn(address indexed payee, uint256 weiAmount);
mapping(address => uint256) private deposits;
function deposit(address _payee) public onlyOwner payable {
uint256 amount = msg.value;
deposits[_payee] = deposits[_payee].add(amount);
emit Deposited(_payee, amount);
}
function withdraw(address _payee) public onlyOwner returns(uint256) {
uint256 payment = deposits[_payee];
assert(address(this).balance >= payment);
deposits[_payee] = 0;
_payee.transfer(payment);
emit Withdrawn(_payee, payment);
return payment;
}
function beneficiaryWithdraw(address _wallet) public onlyOwner {
uint256 _amount = address(this).balance;
_wallet.transfer(_amount);
emit Withdrawn(_wallet, _amount);
}
function depositsOf(address _payee) public view returns(uint256) {
return deposits[_payee];
}
}
contract PullPayment {
Escrow private escrow;
constructor() public {
escrow = new Escrow();
}
function payments(address _dest) public view returns(uint256) {
return escrow.depositsOf(_dest);
}
function _withdrawPayments(address _payee) internal returns(uint256) {
uint256 payment = escrow.withdraw(_payee);
return payment;
}
function _asyncTransfer(address _dest, uint256 _amount) internal {
escrow.deposit.value(_amount)(_dest);
}
function _withdrawFunds(address _wallet) internal {
escrow.beneficiaryWithdraw(_wallet);
}
}
contract VestedCrowdsale {
using SafeMath for uint256;
mapping (address => uint256) public withdrawn;
mapping (address => uint256) public contributions;
mapping (address => uint256) public contributionsRound;
uint256 public vestedTokens;
function getWithdrawableAmount(address _beneficiary) public view returns(uint256) {
uint256 step = _getVestingStep(_beneficiary);
uint256 valueByStep = _getValueByStep(_beneficiary);
uint256 result = step.mul(valueByStep).sub(withdrawn[_beneficiary]);
return result;
}
function _getVestingStep(address _beneficiary) internal view returns(uint8) {
require(contributions[_beneficiary] != 0);
require(contributionsRound[_beneficiary] > 0 && contributionsRound[_beneficiary] < 4);
uint256 march31 = 1554019200;
uint256 april30 = 1556611200;
uint256 may31 = 1559289600;
uint256 june30 = 1561881600;
uint256 july31 = 1564560000;
uint256 sept30 = 1569830400;
uint256 contributionRound = contributionsRound[_beneficiary];
// vesting for private sale contributors
if (contributionRound == 1) {
if (block.timestamp < march31) {
return 0;
}
if (block.timestamp < june30) {
return 1;
}
if (block.timestamp < sept30) {
return 2;
}
return 3;
}
// vesting for pre ico contributors
if (contributionRound == 2) {
if (block.timestamp < april30) {
return 0;
}
if (block.timestamp < july31) {
return 1;
}
return 2;
}
// vesting for ico contributors
if (contributionRound == 3) {
if (block.timestamp < may31) {
return 0;
}
return 1;
}
}
function _getValueByStep(address _beneficiary) internal view returns(uint256) {
require(contributions[_beneficiary] != 0);
require(contributionsRound[_beneficiary] > 0 && contributionsRound[_beneficiary] < 4);
uint256 contributionRound = contributionsRound[_beneficiary];
uint256 amount;
uint256 rate;
if (contributionRound == 1) {
rate = 416700;
amount = contributions[_beneficiary].mul(rate).mul(25).div(100);
return amount;
} else if (contributionRound == 2) {
rate = 312500;
amount = contributions[_beneficiary].mul(rate).mul(25).div(100);
return amount;
}
rate = 250000;
amount = contributions[_beneficiary].mul(rate).mul(25).div(100);
return amount;
}
}
contract Whitelist is Ownable {
// Whitelisted address
mapping(address => bool) public whitelist;
event AddedBeneficiary(address indexed _beneficiary);
event RemovedBeneficiary(address indexed _beneficiary);
function addAddressToWhitelist(address[] _beneficiaries) public onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
emit AddedBeneficiary(_beneficiaries[i]);
}
}
function addToWhitelist(address _beneficiary) public onlyOwner {
whitelist[_beneficiary] = true;
emit AddedBeneficiary(_beneficiary);
}
function removeFromWhitelist(address _beneficiary) public onlyOwner {
whitelist[_beneficiary] = false;
emit RemovedBeneficiary(_beneficiary);
}
}
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 PauserRole {
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));
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(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 totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_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 ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
contract DSLACrowdsale is VestedCrowdsale, Whitelist, Pausable, PullPayment {
// struct to store ico rounds details
struct IcoRound {
uint256 rate;
uint256 individualFloor;
uint256 individualCap;
uint256 softCap;
uint256 hardCap;
}
// mapping ico rounds
mapping (uint256 => IcoRound) public icoRounds;
// The token being sold
ERC20Burnable private _token;
// Address where funds are collected
address private _wallet;
// Amount of wei raised
uint256 private totalContributionAmount;
// Tokens to sell = 5 Billions * 10^18 = 5 * 10^27 = 5000000000000000000000000000
uint256 public constant TOKENSFORSALE = 5000000000000000000000000000;
// Current ico round
uint256 public currentIcoRound;
// Distributed Tokens
uint256 public distributedTokens;
// Amount of wei raised from other currencies
uint256 public weiRaisedFromOtherCurrencies;
// Refund period on
bool public isRefunding = false;
// Finalized crowdsale off
bool public isFinalized = false;
// Refunding deadline
uint256 public refundDeadline;
event TokensPurchased(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(address wallet, ERC20Burnable token) public {
require(wallet != address(0) && token != address(0));
icoRounds[1] = IcoRound(416700,
3 ether,
600 ether,
0,
1200 ether);
icoRounds[2] = IcoRound(312500,
12 ether,
5000 ether,
0,
6000 ether);
icoRounds[3] = IcoRound(250000,
3 ether,
30 ether,
7200 ether,
17200 ether);
_wallet = wallet;
_token = token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _contributor) public payable {
require(whitelist[_contributor]);
uint256 contributionAmount = msg.value;
_preValidatePurchase(_contributor, contributionAmount, currentIcoRound);
totalContributionAmount = totalContributionAmount.add(contributionAmount);
uint tokenAmount = _handlePurchase(contributionAmount, currentIcoRound, _contributor);
emit TokensPurchased(msg.sender, _contributor, contributionAmount, tokenAmount);
_forwardFunds();
}
function goToNextRound() public onlyOwner returns(bool) {
require(currentIcoRound >= 0 && currentIcoRound < 3);
currentIcoRound = currentIcoRound + 1;
return true;
}
function addPrivateSaleContributors(address _contributor, uint256 _contributionAmount)
public onlyOwner
{
uint privateSaleRound = 1;
_preValidatePurchase(_contributor, _contributionAmount, privateSaleRound);
totalContributionAmount = totalContributionAmount.add(_contributionAmount);
addToWhitelist(_contributor);
_handlePurchase(_contributionAmount, privateSaleRound, _contributor);
}
function addOtherCurrencyContributors(address _contributor, uint256 _contributionAmount, uint256 _round)
public onlyOwner
{
_preValidatePurchase(_contributor, _contributionAmount, _round);
weiRaisedFromOtherCurrencies = weiRaisedFromOtherCurrencies.add(_contributionAmount);
addToWhitelist(_contributor);
_handlePurchase(_contributionAmount, _round, _contributor);
}
function closeRefunding() public returns(bool) {
require(isRefunding);
require(block.timestamp > refundDeadline);
isRefunding = false;
_withdrawFunds(wallet());
return true;
}
function closeCrowdsale() public onlyOwner returns(bool) {
require(currentIcoRound > 0 && currentIcoRound < 4);
currentIcoRound = 4;
return true;
}
function finalizeCrowdsale(bool _burn) public onlyOwner returns(bool) {
require(currentIcoRound == 4 && !isRefunding);
if (raisedFunds() < icoRounds[3].softCap) {
isRefunding = true;
refundDeadline = block.timestamp + 4 weeks;
return true;
}
require(!isFinalized);
_withdrawFunds(wallet());
isFinalized = true;
if (_burn) {
_burnUnsoldTokens();
} else {
_withdrawUnsoldTokens();
}
return true;
}
function claimRefund() public {
require(isRefunding);
require(block.timestamp <= refundDeadline);
require(payments(msg.sender) > 0);
uint256 payment = _withdrawPayments(msg.sender);
totalContributionAmount = totalContributionAmount.sub(payment);
}
function claimTokens() public {
require(getWithdrawableAmount(msg.sender) != 0);
uint256 amount = getWithdrawableAmount(msg.sender);
withdrawn[msg.sender] = withdrawn[msg.sender].add(amount);
_deliverTokens(msg.sender, amount);
}
function token() public view returns(ERC20Burnable) {
return _token;
}
function wallet() public view returns(address) {
return _wallet;
}
function raisedFunds() public view returns(uint256) {
return totalContributionAmount.add(weiRaisedFromOtherCurrencies);
}
// -----------------------------------------
// Internal interface
// -----------------------------------------
function _deliverTokens(address _beneficiary, uint256 _tokenAmount)
internal
{
_token.transfer(_beneficiary, _tokenAmount);
}
function _forwardFunds()
internal
{
if (currentIcoRound == 2 || currentIcoRound == 3) {
_asyncTransfer(msg.sender, msg.value);
} else {
_wallet.transfer(msg.value);
}
}
function _getTokensToDeliver(uint _tokenAmount, uint _round)
internal pure returns(uint)
{
require(_round > 0 && _round < 4);
uint deliverPercentage = _round.mul(25);
return _tokenAmount.mul(deliverPercentage).div(100);
}
function _handlePurchase(uint _contributionAmount, uint _round, address _contributor)
internal returns(uint) {
uint256 soldTokens = distributedTokens.add(vestedTokens);
uint256 tokenAmount = _getTokenAmount(_contributionAmount, _round);
require(tokenAmount.add(soldTokens) <= TOKENSFORSALE);
contributions[_contributor] = contributions[_contributor].add(_contributionAmount);
contributionsRound[_contributor] = _round;
uint tokensToDeliver = _getTokensToDeliver(tokenAmount, _round);
uint tokensToVest = tokenAmount.sub(tokensToDeliver);
distributedTokens = distributedTokens.add(tokensToDeliver);
vestedTokens = vestedTokens.add(tokensToVest);
_deliverTokens(_contributor, tokensToDeliver);
return tokenAmount;
}
function _preValidatePurchase(address _contributor, uint256 _contributionAmount, uint _round)
internal view
{
require(_contributor != address(0));
require(currentIcoRound > 0 && currentIcoRound < 4);
require(_round > 0 && _round < 4);
require(contributions[_contributor] == 0);
require(_contributionAmount >= icoRounds[_round].individualFloor);
require(_contributionAmount < icoRounds[_round].individualCap);
require(_doesNotExceedHardCap(_contributionAmount, _round));
}
function _getTokenAmount(uint256 _contributionAmount, uint256 _round)
internal view returns(uint256)
{
uint256 _rate = icoRounds[_round].rate;
return _contributionAmount.mul(_rate);
}
function _doesNotExceedHardCap(uint _contributionAmount, uint _round)
internal view returns(bool)
{
uint roundHardCap = icoRounds[_round].hardCap;
return totalContributionAmount.add(_contributionAmount) <= roundHardCap;
}
function _burnUnsoldTokens()
internal
{
uint256 tokensToBurn = TOKENSFORSALE.sub(vestedTokens).sub(distributedTokens);
_token.burn(tokensToBurn);
}
function _withdrawUnsoldTokens()
internal {
uint256 tokensToWithdraw = TOKENSFORSALE.sub(vestedTokens).sub(distributedTokens);
_token.transfer(_wallet, tokensToWithdraw);
}
}
| 206,872 | 833 |
43c223d9f575e040af3231dc28eb1ed78b51cccfb3980ebe5b888af5dfc07ed3
| 32,272 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0xd688b25b368142a89d2ab4ea87e03b6e69c5717d_affectedByMiners.sol
| 3,490 | 13,433 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (block.timestamp > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// CityToken with Governance.
contract DelhiCityToken is ERC20("DELHI.cityswap.io", "DELHI"), Ownable {
uint256 public constant MAX_SUPPLY = 21285000 * 10**18;
function mint(address _to, uint256 _amount) public onlyOwner {
uint256 _totalSupply = totalSupply();
if(block.number > MAX_SUPPLY) { //injected CONTRACT AFFECTED BY MINERS
_amount = MAX_SUPPLY.sub(_totalSupply);
}
require(_totalSupply.add(_amount) <= MAX_SUPPLY);
_mint(_to, _amount);
}
}
| 281,017 | 834 |
b0051eec7ee85e45f5a4f0309b8ad39c9ce0ee97fd31124114ea1c6cc0dc6676
| 20,322 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0xc28e860c9132d55a184f9af53fc85e90aa3a0153.sol
| 4,136 | 15,612 |
pragma solidity ^0.4.20;
contract POTJ {
/// @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 Trevon James";
string public symbol = "PoTJ";
uint8 constant public decimals = 18;
/// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 20;
/// @dev 10% dividends for token transfer
uint8 constant internal transferFee_ = 10;
/// @dev 25% dividends for token selling
uint8 constant internal exitFee_ = 25;
/// @dev 35% of entryFee_ (i.e. 7% dividends) is given to referrer
uint8 constant internal refferalFee_ = 35;
uint256 constant internal tokenPriceInitial_ = 0.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,924 | 835 |
336a4dcb28c96191cd687b5e83ec1b2823cd0fd86b41683e379ef8b51cb63e30
| 21,688 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/a7/a78e9c7dea0b29c76aa1ca82fe3207b8ac935bea_AaveOracle.sol
| 3,099 | 11,438 |
// Sources flattened with hardhat v2.9.3 https://hardhat.org
// File contracts/dependencies/openzeppelin/contracts/Context.sol
// SPDX-License-Identifier: agpl-3.0
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 contracts/dependencies/openzeppelin/contracts/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/dependencies/openzeppelin/contracts/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 contracts/interfaces/IPriceOracleGetter.sol
interface IPriceOracleGetter {
function getAssetPrice(address asset) external view returns (uint256);
}
// File contracts/interfaces/IChainlinkAggregator.sol
interface IChainlinkAggregator {
function decimals() external view returns (uint8);
function latestAnswer() external view returns (int256);
function latestTimestamp() external view returns (uint256);
function latestRound() external view returns (uint256);
function getAnswer(uint256 roundId) external view returns (int256);
function getTimestamp(uint256 roundId) external view returns (uint256);
event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 timestamp);
event NewRound(uint256 indexed roundId, address indexed startedBy);
}
// File contracts/dependencies/openzeppelin/contracts/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) {
// 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;
}
}
// File contracts/dependencies/openzeppelin/contracts/Address.sol
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');
}
}
// File contracts/dependencies/openzeppelin/contracts/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 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');
}
}
}
// File contracts/misc/AaveOracle.sol
/// @title AaveOracle
/// @author Aave
/// smart contracts as primary option
/// - Owned by the Aave governance system, allowed to add sources for assets, replace them
/// and change the fallbackOracle
contract AaveOracle is IPriceOracleGetter, Ownable {
using SafeERC20 for IERC20;
event BaseCurrencySet(address indexed baseCurrency, uint256 baseCurrencyUnit);
event AssetSourceUpdated(address indexed asset, address indexed source);
event FallbackOracleUpdated(address indexed fallbackOracle);
mapping(address => IChainlinkAggregator) private assetsSources;
IPriceOracleGetter private _fallbackOracle;
address public immutable BASE_CURRENCY;
uint256 public immutable BASE_CURRENCY_UNIT;
/// @notice Constructor
/// @param assets The addresses of the assets
/// @param sources The address of the source of each asset
/// @param fallbackOracle The address of the fallback oracle to use if the data of an
/// aggregator is not consistent
/// @param baseCurrencyUnit the unit of the base currency
constructor(address[] memory assets,
address[] memory sources,
address fallbackOracle,
address baseCurrency,
uint256 baseCurrencyUnit) public {
_setFallbackOracle(fallbackOracle);
_setAssetsSources(assets, sources);
BASE_CURRENCY = baseCurrency;
BASE_CURRENCY_UNIT = baseCurrencyUnit;
emit BaseCurrencySet(baseCurrency, baseCurrencyUnit);
}
/// @notice External function called by the Aave governance to set or replace sources of assets
/// @param assets The addresses of the assets
/// @param sources The address of the source of each asset
function setAssetSources(address[] calldata assets, address[] calldata sources)
external
onlyOwner
{
_setAssetsSources(assets, sources);
}
/// @notice Sets the fallbackOracle
/// - Callable only by the Aave governance
/// @param fallbackOracle The address of the fallbackOracle
function setFallbackOracle(address fallbackOracle) external onlyOwner {
_setFallbackOracle(fallbackOracle);
}
/// @notice Internal function to set the sources for each asset
/// @param assets The addresses of the assets
/// @param sources The address of the source of each asset
function _setAssetsSources(address[] memory assets, address[] memory sources) internal {
require(assets.length == sources.length, 'INCONSISTENT_PARAMS_LENGTH');
for (uint256 i = 0; i < assets.length; i++) {
assetsSources[assets[i]] = IChainlinkAggregator(sources[i]);
emit AssetSourceUpdated(assets[i], sources[i]);
}
}
/// @notice Internal function to set the fallbackOracle
/// @param fallbackOracle The address of the fallbackOracle
function _setFallbackOracle(address fallbackOracle) internal {
_fallbackOracle = IPriceOracleGetter(fallbackOracle);
emit FallbackOracleUpdated(fallbackOracle);
}
/// @notice Gets an asset price by address
/// @param asset The asset address
function getAssetPrice(address asset) public view override returns (uint256) {
IChainlinkAggregator source = assetsSources[asset];
if (asset == BASE_CURRENCY) {
return BASE_CURRENCY_UNIT;
} else if (address(source) == address(0)) {
return _fallbackOracle.getAssetPrice(asset);
} else {
int256 price = IChainlinkAggregator(source).latestAnswer();
if (price > 0) {
return uint256(price);
} else {
return _fallbackOracle.getAssetPrice(asset);
}
}
}
/// @notice Gets a list of prices from a list of assets addresses
/// @param assets The list of assets addresses
function getAssetsPrices(address[] calldata assets) external view returns (uint256[] memory) {
uint256[] memory prices = new uint256[](assets.length);
for (uint256 i = 0; i < assets.length; i++) {
prices[i] = getAssetPrice(assets[i]);
}
return prices;
}
/// @notice Gets the address of the source for an asset address
/// @param asset The address of the asset
/// @return address The address of the source
function getSourceOfAsset(address asset) external view returns (address) {
return address(assetsSources[asset]);
}
/// @notice Gets the address of the fallback oracle
/// @return address The addres of the fallback oracle
function getFallbackOracle() external view returns (address) {
return address(_fallbackOracle);
}
}
| 118,975 | 836 |
c24935abd4b093192fe907a1e98739354bea3d872e4f94237e8354b7b0e08128
| 29,309 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2AdBD412F4cdb731020a21b5A4823600219f73ad/contract.sol
| 3,461 | 14,216 |
// SPDX-License-Identifier: MIT
// solhint-disable-next-line compiler-version
pragma solidity >=0.4.24 <0.8.0;
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
// solhint-disable-next-line no-inline-assembly
assembly {
cs := extcodesize(self)
}
return cs == 0;
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMathUpgradeable {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable {
using SafeMathUpgradeable for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
function __ERC20_init(string memory name_, string memory symbol_) internal initializer {
__Context_init_unchained();
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {
_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 {}
uint256[44] private __gap;
}
interface ILnAccessControl {
function hasRole(bytes32 role, address account) external view returns (bool);
function ISSUE_ASSET_ROLE() external view returns (bytes32);
function BURN_ASSET_ROLE() external view returns (bytes32);
function DEBT_SYSTEM() external view returns (bytes32);
function IsAdmin(address _address) external view returns (bool);
function SetAdmin(address _address) external returns (bool);
function SetRoles(bytes32 roleType,
address[] calldata addresses,
bool[] calldata setTo) external;
function SetIssueAssetRole(address[] calldata issuer, bool[] calldata setTo) external;
function SetBurnAssetRole(address[] calldata burner, bool[] calldata setTo) external;
function SetDebtSystemRole(address[] calldata _address, bool[] calldata _setTo) external;
}
contract LnAdmin {
address public admin;
address public candidate;
constructor(address _admin) public {
require(_admin != address(0), "admin address cannot be 0");
admin = _admin;
emit AdminChanged(address(0), _admin);
}
function setCandidate(address _candidate) external onlyAdmin {
address old = candidate;
candidate = _candidate;
emit CandidateChanged(old, candidate);
}
function becomeAdmin() external {
require(msg.sender == candidate, "Only candidate can become admin");
address old = admin;
admin = candidate;
emit AdminChanged(old, admin);
}
modifier onlyAdmin {
require((msg.sender == admin), "Only the contract admin can perform this action");
_;
}
event CandidateChanged(address oldCandidate, address newCandidate);
event AdminChanged(address oldAdmin, address newAdmin);
}
interface ILnAddressStorage {
function updateAll(bytes32[] calldata names, address[] calldata destinations) external;
function update(bytes32 name, address dest) external;
function getAddress(bytes32 name) external view returns (address);
function getAddressWithRequire(bytes32 name, string calldata reason) external view returns (address);
}
abstract contract LnAddressCache {
function updateAddressCache(ILnAddressStorage _addressStorage) external virtual;
event CachedAddressUpdated(bytes32 name, address addr);
}
contract testAddressCache is LnAddressCache, LnAdmin {
address public addr1;
address public addr2;
constructor(address _admin) public LnAdmin(_admin) {}
function updateAddressCache(ILnAddressStorage _addressStorage) public override onlyAdmin {
addr1 = _addressStorage.getAddressWithRequire("a", "");
addr2 = _addressStorage.getAddressWithRequire("b", "");
emit CachedAddressUpdated("a", addr1);
emit CachedAddressUpdated("b", addr2);
}
}
contract LnAdminUpgradeable is Initializable {
event CandidateChanged(address oldCandidate, address newCandidate);
event AdminChanged(address oldAdmin, address newAdmin);
address public admin;
address public candidate;
function __LnAdminUpgradeable_init(address _admin) public initializer {
require(_admin != address(0), "LnAdminUpgradeable: zero address");
admin = _admin;
emit AdminChanged(address(0), _admin);
}
function setCandidate(address _candidate) external onlyAdmin {
address old = candidate;
candidate = _candidate;
emit CandidateChanged(old, candidate);
}
function becomeAdmin() external {
require(msg.sender == candidate, "LnAdminUpgradeable: only candidate can become admin");
address old = admin;
admin = candidate;
emit AdminChanged(old, admin);
}
modifier onlyAdmin {
require((msg.sender == admin), "LnAdminUpgradeable: only the contract admin can perform this action");
_;
}
// Reserved storage space to allow for layout changes in the future.
uint256[48] private __gap;
}
contract LnAssetUpgradeable is ERC20Upgradeable, LnAdminUpgradeable, LnAddressCache {
bytes32 mKeyName;
ILnAccessControl accessCtrl;
modifier onlyIssueAssetRole(address _address) {
require(accessCtrl.hasRole(accessCtrl.ISSUE_ASSET_ROLE(), _address), "Need issue access role");
_;
}
modifier onlyBurnAssetRole(address _address) {
require(accessCtrl.hasRole(accessCtrl.BURN_ASSET_ROLE(), _address), "Need burn access role");
_;
}
function __LnAssetUpgradeable_init(bytes32 _key,
string memory _name,
string memory _symbol,
address _admin) public initializer {
__ERC20_init(_name, _symbol);
__LnAdminUpgradeable_init(_admin);
mKeyName = _key;
}
function keyName() external view returns (bytes32) {
return mKeyName;
}
function updateAddressCache(ILnAddressStorage _addressStorage) public override onlyAdmin {
accessCtrl = ILnAccessControl(_addressStorage.getAddressWithRequire("LnAccessControl", "LnAccessControl address not valid"));
emit CachedAddressUpdated("LnAccessControl", address(accessCtrl));
}
function mint(address account, uint256 amount) external onlyIssueAssetRole(msg.sender) {
_mint(account, amount);
}
function burn(address account, uint amount) external onlyBurnAssetRole(msg.sender) {
_burn(account, amount);
}
// Reserved storage space to allow for layout changes in the future.
uint256[48] private __gap;
}
| 250,910 | 837 |
1cdf73371044be0a6966889474b91b4fcde5e130dd62252614739cb37d30e638
| 12,485 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Dependency_of_timestamp/Sol/buggy_19.sol
| 3,364 | 11,453 |
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract owned {
address winner_tmstmp30;
function play_tmstmp30(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp30 = msg.sender;}}
address public owner;
constructor() public {
owner = msg.sender;
}
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;}}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
uint256 bugv_tmstmp1 = block.timestamp;
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
function bug_tmstmp29() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
}
contract ethBank is owned{
function () payable external {}
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);
}
}
function withdrawForUser(address _address,uint amount) onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
_address.transfer(amount);
}
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 moveBrick(uint amount) onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(amount);
}
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 moveBrickContracts() onlyOwner public
{
// only team just can withdraw Contracts
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
function bug_tmstmp25() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
// either settled or refunded. All funds are transferred to contract owner.
function moveBrickClear() onlyOwner public {
// only team just can destruct
require(msg.sender == owner, "only owner can use this method");
selfdestruct(msg.sender);
}
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 joinFlexible() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 joinFixed() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
address winner_tmstmp22;
function play_tmstmp22(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp22 = msg.sender;}}
function staticBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
function bug_tmstmp21() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function activeBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 teamAddBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 staticBonusCacl() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 activeBonusCacl_1() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 activeBonusCacl_2() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
function bug_tmstmp17() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function activeBonusCacl_3() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 activeBonusCacl_4() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 activeBonusCacl_5() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 activeBonusCacl_6() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function activeBonusCacl_7() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 activeBonusCacl_8() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 activeBonusCacl_9() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
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 teamAddBonusCacl() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
function bug_tmstmp1() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function caclTeamPerformance() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
uint256 bugv_tmstmp5 = block.timestamp;
function releaStaticBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
uint256 bugv_tmstmp4 = block.timestamp;
function releaActiveBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
uint256 bugv_tmstmp3 = block.timestamp;
function releaTeamAddBonus() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
uint256 bugv_tmstmp2 = block.timestamp;
}
| 223,838 | 838 |
6433f391b9e28a36c59edf2fdfa6c2e4dd8a0f8f6a3fd8bd2a3acc1c579133c4
| 35,021 |
.sol
|
Solidity
| false |
445197756
|
feature-sh/smart-contract
|
b0dd9772599f327287b889d106614fa6fd92df87
|
contracts/FeatureERC20.sol
| 5,360 | 21,530 |
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
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;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly {
cs := extcodesize(self)
}
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract EIP712Base is Initializable {
struct EIP712Domain {
string name;
string version;
address verifyingContract;
bytes32 salt;
}
bytes32 internal constant EIP712_DOMAIN_TYPEHASH =
keccak256(bytes("EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"));
bytes32 internal domainSeperator;
// supposed to be called once while initializing.
// one of the contractsa that inherits this contract follows proxy pattern
// so it is not possible to do this in a constructor
function _initializeEIP712(string memory name, string memory version) internal initializer {
_setDomainSeperator(name, version);
}
function _setDomainSeperator(string memory name, string memory version) internal {
domainSeperator = keccak256(abi.encode(EIP712_DOMAIN_TYPEHASH,
keccak256(bytes(name)),
keccak256(bytes(version)),
address(this),
bytes32(getChainId())));
}
function getDomainSeperator() public view returns (bytes32) {
return domainSeperator;
}
function getChainId() public view returns (uint256) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
function toTypedMessageHash(bytes32 messageHash) internal view returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash));
}
}
contract NativeMetaTransaction is EIP712Base {
bytes32 private constant META_TRANSACTION_TYPEHASH =
keccak256(bytes("MetaTransaction(uint256 nonce,address from,bytes functionSignature)"));
event MetaTransactionExecuted(address userAddress, address relayerAddress, bytes functionSignature);
mapping(address => uint256) nonces;
struct MetaTransaction {
uint256 nonce;
address from;
bytes functionSignature;
}
function executeMetaTransaction(address userAddress,
bytes memory functionSignature,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) public payable returns (bytes memory) {
MetaTransaction memory metaTx = MetaTransaction({
nonce: nonces[userAddress],
from: userAddress,
functionSignature: functionSignature
});
require(verify(userAddress, metaTx, sigR, sigS, sigV), "Signer and signature do not match");
// increase nonce for user (to avoid re-use)
uint256 noncesByUser = nonces[userAddress];
require(noncesByUser + 1 >= noncesByUser, "Must be not an overflow");
nonces[userAddress] = noncesByUser + 1;
emit MetaTransactionExecuted(userAddress, msg.sender, functionSignature);
// Append userAddress and relayer address at the end to extract it from calling context
(bool success, bytes memory returnData) = address(this).call(abi.encodePacked(functionSignature, userAddress));
require(success, "Function call not successful");
return returnData;
}
function hashMetaTransaction(MetaTransaction memory metaTx) internal pure returns (bytes32) {
return
keccak256(abi.encode(META_TRANSACTION_TYPEHASH, metaTx.nonce, metaTx.from, keccak256(metaTx.functionSignature)));
}
function getNonce(address user) public view returns (uint256 nonce) {
nonce = nonces[user];
}
function verify(address signer,
MetaTransaction memory metaTx,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) internal view returns (bool) {
require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
return signer == ecrecover(toTypedMessageHash(hashMetaTransaction(metaTx)), sigV, sigR, sigS);
}
}
contract ChainConstants {
string public constant ERC712_VERSION = "1";
uint256 public constant ROOT_CHAIN_ID = 1;
bytes public constant ROOT_CHAIN_ID_BYTES = hex"01";
uint256 public constant CHILD_CHAIN_ID = 5;
bytes public constant CHILD_CHAIN_ID_BYTES = hex"05";
}
abstract contract ContextMixin {
function msgSender() internal view returns (address sender) {
if (msg.sender == address(this)) {
bytes memory array = msg.data;
uint256 index = msg.data.length;
assembly {
// Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
sender := and(mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff)
}
} else {
sender = msg.sender;
}
return sender;
}
}
interface IArbitrable {
event MetaEvidence(uint256 indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator,
uint256 indexed _disputeID,
uint256 _metaEvidenceID,
uint256 _evidenceGroupID);
event Evidence(Arbitrator indexed _arbitrator,
uint256 indexed _evidenceGroupID,
address indexed _party,
string _evidence);
event Ruling(Arbitrator indexed _arbitrator, uint256 indexed _disputeID, uint256 _ruling);
function rule(uint256 _disputeID, uint256 _ruling) external;
}
abstract contract Arbitrable is IArbitrable {
Arbitrator public arbitrator;
bytes public arbitratorExtraData; // Extra data to require particular dispute and appeal behaviour.
modifier onlyArbitrator() {
require(msg.sender == address(arbitrator), "Can only be called by the arbitrator.");
_;
}
constructor(Arbitrator _arbitrator, bytes storage _arbitratorExtraData) {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
}
function rule(uint256 _disputeID, uint256 _ruling) external override onlyArbitrator {
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(_disputeID, _ruling);
}
function executeRuling(uint256 _disputeID, uint256 _ruling) internal virtual;
}
abstract contract Arbitrator {
enum DisputeStatus {
Waiting,
Appealable,
Solved
}
modifier requireArbitrationFee(bytes calldata _extraData) {
require(msg.value >= arbitrationCost(_extraData), "Not enough ETH to cover arbitration costs.");
_;
}
modifier requireAppealFee(uint256 _disputeID, bytes calldata _extraData) {
require(msg.value >= appealCost(_disputeID, _extraData), "Not enough ETH to cover appeal costs.");
_;
}
event DisputeCreation(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealPossible(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealDecision(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
function createDispute(uint256 _choices, bytes calldata _extraData)
public
payable
requireArbitrationFee(_extraData)
returns (uint256 disputeID)
{}
function arbitrationCost(bytes calldata _extraData) public view virtual returns (uint256 fee);
function appeal(uint256 _disputeID, bytes calldata _extraData)
public
payable
requireAppealFee(_disputeID, _extraData)
{
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
function appealCost(uint256 _disputeID, bytes calldata _extraData) public view virtual returns (uint256 fee);
function appealPeriod(uint256 _disputeID) public view virtual returns (uint256 start, uint256 end) {}
function disputeStatus(uint256 _disputeID) public view virtual returns (DisputeStatus status);
function currentRuling(uint256 _disputeID) public view virtual returns (uint256 ruling);
}
contract FeatureERC20 is Initializable, NativeMetaTransaction, ChainConstants, ContextMixin, IArbitrable {
// **************************** //
// * Contract variables * //
// **************************** //
// Amount of choices to solve the dispute if needed.
uint8 constant AMOUNT_OF_CHOICES = 2;
// Enum relative to different periods in the case of a negotiation or dispute.
enum Status {
WaitingForChallenger,
DisputeCreated,
Resolved
}
// The different parties of the dispute.
enum Party {
Receiver,
Challenger
}
// The different ruling for the dispute resolution.
enum RulingOptions {
NoRuling,
ReceiverWins,
ChallengerWins
}
struct Transaction {
address sender;
Arbitrator arbitrator; // The arbitrator of the contract.
bytes arbitratorExtraData; // Extra data for the arbitrator.
IERC20 token; // Address of the ERC20 token.
uint256 amount; // Amount of the reward in Wei.
uint256 deposit; // Amount of the deposit in Wei.
uint256 timeoutPayment; // Time in seconds after which the transaction can be executed if not disputed.
uint256 delayClaim; // Time of the challenge period.
string metaEvidence; // Link to the meta-evidence.
uint256 runningClaimCount; // Count of running claims.
bool isExecuted;
}
struct Claim {
uint256 transactionID; // Relation one-to-one with the transaction.
address receiver; // Address of the receiver.
address challenger; // Address of the challenger.
string proof; // Link to the proof.
uint256 timeoutClaim; // Time of the outdated challenge period.
uint256 receiverFee; // Total fees paid by the receiver.
uint256 challengerFee; // Total fees paid by the challenge.
uint256 disputeID; // If dispute exists, the ID of the dispute.
Status status; // Status of the the dispute.
}
Transaction[] public transactions;
Claim[] public claims;
mapping(uint256 => uint256) public disputeIDtoClaimID; // One-to-one relationship between the dispute and the claim.
// **************************** //
// * Events * //
// **************************** //
event Payment(uint256 indexed _transactionID, uint256 _amount, address _receiver);
event Refund(uint256 indexed _transactionID, uint256 _amount, address _party);
event ClaimSubmit(uint256 indexed _transactionID, uint256 _claimID, address _receiver);
event HasToPayFee(uint256 indexed _transactionID, Party _party);
// **************************** //
// * Contract functions * //
// * Modifying the state * //
// **************************** //
function initialize() public initializer {
_initializeEIP712("FeatureERC20", ERC712_VERSION);
}
// This is to support Native meta transactions
// never use msg.sender directly, use _msgSender() instead
function _msgSender() internal view returns (address sender) {
return ContextMixin.msgSender();
}
function createTransaction(Arbitrator _arbitrator,
bytes memory _arbitratorExtraData,
IERC20 _token,
uint256 _amount,
uint256 _deposit,
uint256 _timeoutPayment,
uint256 _delayClaim,
string memory _metaEvidence) public payable returns (uint256 transactionID) {
// Transfers token from sender wallet to contract.
require(_token.transferFrom(msgSender(), address(this), _amount),
"Sender does not have enough approved funds.");
transactions.push(Transaction({
sender: _msgSender(),
arbitrator: _arbitrator,
arbitratorExtraData: _arbitratorExtraData,
token: _token,
amount: _amount,
deposit: _deposit,
timeoutPayment: _timeoutPayment + block.timestamp,
delayClaim: _delayClaim,
metaEvidence: _metaEvidence,
runningClaimCount: 0,
isExecuted: false
}));
// Store the meta-evidence.
emit MetaEvidence(transactions.length - 1, _metaEvidence);
return transactions.length - 1;
}
function claim(uint256 _transactionID, string memory _proof) public payable returns (uint256 claimID) {
return _claimFor(_transactionID, _msgSender(), _proof);
}
function claimFor(uint256 _transactionID, address _receiver, string memory _proof) public payable returns (uint256 claimID) {
return _claimFor(_transactionID, _receiver, _proof);
}
function _claimFor(uint256 _transactionID, address _receiver, string memory _proof) internal returns (uint256 claimID) {
Transaction storage transaction = transactions[_transactionID];
uint256 arbitrationCost = transaction.arbitrator.arbitrationCost(transaction.arbitratorExtraData);
require(msg.value >= transaction.deposit + arbitrationCost,
"The challenger fee must cover the deposit and the arbitration costs.");
claims.push(Claim({
transactionID: _transactionID,
receiver: _receiver,
challenger: address(0),
proof: _proof,
timeoutClaim: transaction.delayClaim + block.timestamp,
receiverFee: arbitrationCost,
challengerFee: 0,
disputeID: 0,
status: Status.WaitingForChallenger
}));
claimID = claims.length - 1;
transaction.runningClaimCount++;
emit ClaimSubmit(_transactionID, claimID, _receiver);
return claimID;
}
function pay(uint256 _claimID) public {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(transaction.isExecuted == false, "The transaction should not be executed.");
require(claim.timeoutClaim <= block.timestamp, "The timeout claim should be passed.");
require(claim.status == Status.WaitingForChallenger, "The transaction shouldn't be disputed.");
transaction.isExecuted = true;
claim.status = Status.Resolved;
payable(claim.receiver).transfer(transaction.deposit + claim.receiverFee);
IERC20(transaction.token).transfer(claim.receiver, transaction.amount);
emit Payment(claim.transactionID, transaction.amount, claim.receiver);
}
function refund(uint256 _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.isExecuted == false, "The transaction should not be refunded.");
require(transaction.timeoutPayment <= block.timestamp, "The timeout payment should be passed.");
require(transaction.runningClaimCount == 0, "The transaction should not to have running claims.");
transaction.isExecuted = true;
IERC20(transaction.token).transfer(transaction.sender, transaction.amount);
emit Refund(_transactionID, transaction.amount, transaction.sender);
}
function challengeClaim(uint256 _claimID) public payable {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
uint256 arbitrationCost = transaction.arbitrator.arbitrationCost(transaction.arbitratorExtraData);
require(claim.status < Status.DisputeCreated,
"Dispute has already been created or because the transaction has been executed.");
require(msg.value >= transaction.deposit + arbitrationCost,
"The challenger fee must cover the deposit and the arbitration costs.");
claim.challengerFee = arbitrationCost;
claim.challenger = _msgSender();
raiseDispute(_claimID, arbitrationCost);
}
function raiseDispute(uint256 _claimID, uint256 _arbitrationCost) internal {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
claim.status = Status.DisputeCreated;
claim.disputeID = transaction.arbitrator.createDispute{value: _arbitrationCost}(AMOUNT_OF_CHOICES,
transaction.arbitratorExtraData);
disputeIDtoClaimID[claim.disputeID] = _claimID;
emit Dispute(transaction.arbitrator, claim.disputeID, _claimID, _claimID);
// Refund receiver if it overpaid.
if (claim.receiverFee > _arbitrationCost) {
uint256 extraFeeSender = claim.receiverFee - _arbitrationCost;
claim.receiverFee = _arbitrationCost;
payable(claim.receiver).send(extraFeeSender);
}
// Refund challenger if it overpaid.
if (claim.challengerFee > _arbitrationCost) {
uint256 extraFeeChallenger = claim.challengerFee - _arbitrationCost;
claim.challengerFee = _arbitrationCost;
payable(claim.challenger).send(extraFeeChallenger);
}
}
function submitEvidence(uint256 _claimID, string memory _evidence) public {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(claim.status < Status.Resolved, "Must not send evidence if the dispute is resolved.");
emit Evidence(transaction.arbitrator, _claimID, _msgSender(), _evidence);
}
function appeal(uint256 _claimID) public payable {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
transaction.arbitrator.appeal{value: msg.value}(claim.disputeID, transaction.arbitratorExtraData);
}
function rule(uint256 _disputeID, uint256 _ruling) external override {
uint256 claimID = disputeIDtoClaimID[_disputeID];
Claim storage claim = claims[claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(msg.sender == address(transaction.arbitrator), "The caller must be the arbitrator.");
require(claim.status == Status.DisputeCreated, "The dispute has already been resolved.");
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(claimID, _ruling);
}
function executeRuling(uint256 _claimID, uint256 _ruling) internal {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(_ruling <= AMOUNT_OF_CHOICES, "Must be a valid ruling.");
// Give the arbitration fee back.
// Note: we use send to prevent a party from blocking the execution.
if (_ruling == uint256(RulingOptions.ReceiverWins)) {
payable(claim.receiver).send(transaction.deposit);
claim.status = Status.WaitingForChallenger;
} else if (_ruling == uint256(RulingOptions.ChallengerWins)) {
payable(claim.challenger).send(claim.challengerFee + transaction.deposit * 2);
claim.status = Status.Resolved;
} else {
payable(claim.challenger).send(claim.challengerFee + transaction.deposit);
claim.status = Status.WaitingForChallenger;
}
transaction.runningClaimCount--;
}
// **************************** //
// * Constant getters * //
// **************************** //
function getCountTransactions() public view returns (uint256 countTransactions) {
return transactions.length;
}
function getTransactionIDsByAddress(address _address) public view returns (uint256[] memory transactionIDs) {
uint256 count = 0;
for (uint256 i = 0; i < transactions.length; i++) {
if (transactions[i].sender == _address) count++;
}
transactionIDs = new uint256[](count);
count = 0;
for (uint256 j = 0; j < transactions.length; j++) {
if (transactions[j].sender == _address) transactionIDs[count++] = j;
}
}
function getClaimIDsByAddress(address _address) public view returns (uint256[] memory claimIDs) {
uint256 count = 0;
for (uint256 i = 0; i < claims.length; i++) {
if (claims[i].receiver == _address) count++;
}
claimIDs = new uint256[](count);
count = 0;
for (uint256 j = 0; j < claims.length; j++) {
if (claims[j].receiver == _address) claimIDs[count++] = j;
}
}
}
| 238,212 | 839 |
63f00b6c9e893a4ebb585d74ef50b0bb079cc428460303b1dfaad8cfaafb578b
| 30,839 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/2a/2AB9dddB853fdF56bf3Be13ee1671e3b68DEAF6c_AutoCompound.sol
| 4,483 | 18,326 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IArbiDexRouter {
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
}
interface ISmartChefInitializable {
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
uint256 rewardDebt; // Reward debt
}
function userInfo(address user) external view returns (uint256, uint256);
function stakedToken() external view returns (address);
function rewardToken() external view returns (address);
function deposit(uint256 _amount) external;
function withdraw(uint256 _amount) 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;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File: @openzeppelin/contracts/utils/ReentrancyGuard.sol
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File: @openzeppelin/contracts/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) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AutoCompound is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
// The address of the treasury where all of the deposit and performance fees are sent
address public treasury;
// The address of the router that is used for conducting swaps
address immutable public router;
// The address of the underlying staker where the deposits and withdrawals are made
address immutable public staker;
// The reward token
address immutable public rewardToken;
// The staked token
address immutable public stakedToken;
// The address of the USDC token
address immutable USDC = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8;
// The fee associated with depositing into the Auto Compounder
uint256 public depositFee = 100;
// The performance fee associated whenever the farm/pool is Auto Compounded
uint256 public performanceFee = 450;
// The minimum amount of reward tokens required for swapping of harvested tokens to occur
uint256 public minimumHarvest;
// The total supply of staked tokens, that have be deposited by users
uint256 totalSupply;
address[] path;
// Info of each user that stakes tokens (stakedToken)
mapping(address => UserInfo) public userInfo;
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
}
constructor(address _treasury,
address _router,
address _staker,
uint256 _minimumHarvest) {
treasury = _treasury;
router = _router;
staker = _staker;
rewardToken = ISmartChefInitializable(staker).rewardToken();
stakedToken = ISmartChefInitializable(staker).stakedToken();
minimumHarvest = _minimumHarvest;
if (rewardToken != USDC) {
path = new address[](3);
path[0] = rewardToken; path[1] = USDC; path[2] = stakedToken;
} else {
path = new address[](2);
path[0] = rewardToken; path[1] = stakedToken;
}
}
event Harvest(uint256 amount);
event Deposit(address indexed user, uint256 amount);
event TokenRecovery(address indexed token, uint256 amount);
event NewMinimumHarvest(uint256 amount);
event NewPerformanceFee(uint256 amount);
event NewDepositFee(uint256 amount);
event TreasuryAddressChanged(address treasury);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
function harvest() public {
// Lets harvest the tokens from the underlying staker
ISmartChefInitializable(staker).deposit(0);
uint256 harvested = IERC20Metadata(rewardToken).balanceOf(address(this));
// Check to see if we have the minimum amount of reward tokens harvested
if (harvested < minimumHarvest) {return;}
// Check allowance and see if we need to update
if (harvested > IERC20Metadata(rewardToken).allowance(address(this), router)) {
IERC20Metadata(rewardToken).safeApprove(router, type(uint256).max);
}
// Calculate the performance fee for this harvest, and send it to the treasury
uint256 feeAmount = (harvested * performanceFee)/10000;
harvested = harvested - feeAmount;
IERC20Metadata(rewardToken).safeTransfer(treasury, feeAmount);
// Lets' compute the amount of tokens we will get out for swapping from reward to staked token
uint256[] memory amounts = IArbiDexRouter(router).getAmountsOut(harvested, path);
// As long as we get 90% of our tokens back from the swap we are good to go
uint256 amountOutMin = (amounts[amounts.length-1] * 90)/100;
// Execute the swap and get the staked token
IArbiDexRouter(router).swapExactTokensForTokens(harvested, amountOutMin, path, address(this), block.timestamp);
uint256 compounded = IERC20(stakedToken).balanceOf(address(this));
ISmartChefInitializable(staker).deposit(compounded);
emit Harvest(compounded);
}
function deposit(uint256 _amount) external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(_amount > 0, "Amount to deposit must be greater than zero");
// Check allowance and see if we need to update
if (_amount > IERC20Metadata(stakedToken).allowance(address(this), staker)) {
IERC20Metadata(stakedToken).safeApprove(staker, type(uint256).max);
}
harvest();
IERC20Metadata(stakedToken).safeTransferFrom(address(msg.sender), address(this), _amount);
uint256 feeAmount = (_amount * depositFee)/10000;
_amount -= feeAmount;
user.amount += _amount;
totalSupply += _amount;
IERC20Metadata(stakedToken).safeTransfer(treasury, feeAmount);
ISmartChefInitializable(staker).deposit(_amount);
emit Deposit(msg.sender, _amount);
}
function withdraw(uint256 _amount) external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(user.amount - _amount >= 0, "Amount to withdraw too high");
require(_amount > 0, "Amount to withdraw cannot be zero");
harvest();
uint256 adjustedAmount = (user.amount * getTotalSupply()) / totalSupply;
totalSupply -= user.amount;
user.amount -= _amount;
ISmartChefInitializable(staker).withdraw(adjustedAmount);
IERC20Metadata(stakedToken).safeTransfer(address(msg.sender), adjustedAmount);
emit Withdraw(msg.sender, _amount);
}
function emergencyWithdraw() external {
UserInfo storage user = userInfo[msg.sender];
require(user.amount > 0, "Nothing to withdraw");
uint256 adjustedAmount = (user.amount * getTotalSupply()) / totalSupply;
totalSupply -= user.amount;
user.amount = 0;
ISmartChefInitializable(staker).withdraw(adjustedAmount);
IERC20Metadata(stakedToken).safeTransfer(address(msg.sender), adjustedAmount);
emit EmergencyWithdraw(msg.sender, user.amount);
}
function adjustedTokenPerShare() public view returns (uint256 _amount) {
return ((10 ** 18) * getTotalSupply()) / totalSupply;
}
function getTotalSupply() public view returns (uint256 _amount) {
(uint256 supply,) = ISmartChefInitializable(staker).userInfo(address(this));
supply += IERC20Metadata(stakedToken).balanceOf(address(this));
return supply;
}
function recoverToken(address _token, uint256 _amount) external onlyOwner {
require(_token != address(0), "Operations: Cannot be zero address");
require(_token != address(stakedToken), "Operations: Cannot be staked token");
require(_token != address(rewardToken), "Operations: Cannot be reward token");
IERC20(_token).transfer(treasury, _amount);
emit TokenRecovery(_token, _amount);
}
function setMinimumHarvest(uint256 _amount) external onlyOwner {
minimumHarvest = _amount;
emit NewMinimumHarvest(_amount);
}
function setTreasury(address _treasury) external onlyOwner {
require(_treasury != address(0), "Address cannot be null");
treasury = _treasury;
emit TreasuryAddressChanged(_treasury);
}
function setDepositFee(uint256 _amount) external onlyOwner {
require(_amount >= 10, "Operations: Invalid deposit fee amount");
require(_amount <= 500, "Operations: Invalid deposit fee amount");
depositFee = _amount;
emit NewDepositFee(_amount);
}
function setPerformanceFee(uint256 _amount) external onlyOwner {
require(_amount >= 200, "Operations: Invalid performance fee amount");
require(_amount <= 500, "Operations: Invalid performance fee amount");
performanceFee = _amount;
emit NewPerformanceFee(_amount);
}
}
| 30,564 | 840 |
633cf41a9b02247a96a25be11df9213cce6f0d35f34f3f3700137a248dbd463b
| 19,920 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TF4mxfZ9cieRJaGXfYJYkqMRUVJHaFGMzP_Trethos.sol
| 5,594 | 19,219 |
//SourceUnit: trethose.sol
pragma solidity 0.5.8;
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 Trethos {
using SafeMath for uint;
struct User { // user struct
uint256 cycle; // deposit cycles
address upline; // referrer
uint256 referrals; // referrals count
mapping(uint256 => uint256) payouts; // payout of deposits by cycle
uint256 direct_bonus; // referral bonus
uint256 hold_bonus; // matching bonus
uint256 activeDepositBonus;
mapping(uint256 => uint256) deposit_amount; // deposit amount by cycle
uint256 currentCycle; // current deposit cycle
mapping(uint256 => uint256) deposit_payouts; // deposit payout by cycle
mapping(uint256 => uint256) deposit_time; // deposit time by cycle
uint256 total_deposits; // total deposits
uint256 total_payouts; // total payout received
uint256 total_structure; // total upline structures
}
address public ownerWallet; // ownerWallet
address public distributor; // distributor address
uint public minimum_deposit = 250 trx; // minimum deposit
uint public total_withdraw; // contract total withdraw
uint public lastFeeDistribution = now+21600;
uint public communityPool;
uint public MAX_LIMIT = 25000000 trx;
uint[] public cycles;
uint[] public managementFee;
mapping(address => User) public users;
mapping(uint => mapping(uint => uint)) public levelPrice;
mapping(uint => uint) public level;
mapping(uint => uint) public managementPool;
mapping(uint => address) public management_fee_Wallet;
mapping(uint => address) public community_fee_Wallet;
event Upline(address indexed addr, address indexed upline, uint _downline, uint _level, uint _amount, uint _time);
event setUpline(address indexed addr, address indexed upline, uint _level, uint _time);
event NewDeposit(address indexed addr, uint256 amount, uint _time);
event DirectPayout(address indexed addr, address indexed from, uint256 amount, uint _time);
event MatchPayout(address indexed addr, address indexed from, uint256 amount, uint _time);
event PoolPayout(address indexed addr, uint256 amount, uint _time);
event Withdraw(address indexed addr, uint dailyPayout, uint directBonus, uint holdBonus, uint activeDeposit, uint256 amount, uint _time);
event LimitReached(address indexed addr, uint256 amount, uint _time);
event managementFeeEvent(address indexed addr, uint amount, uint time);
event communityFeeEvent(address indexed addr, uint amount, uint time);
event activeDepositEvent(address indexed addr, uint amount, uint time);
constructor(address _distributor) public {
ownerWallet = msg.sender;
distributor = _distributor;
//cycles
cycles.push(2e11);
cycles.push(5e11);
cycles.push(1e12);
cycles.push(12e11);
cycles.push(15e11);
cycles.push(17e11);
cycles.push(2e12);
cycles.push(2e12);
cycles.push(22e11);
cycles.push(25e12);
// levels %
// level - 1
levelPrice[1][1] = 5e6;
levelPrice[1][2] = 2e6;
levelPrice[1][3] = 1e6;
levelPrice[1][4] = 1e6;
levelPrice[1][5] = 5e5;
levelPrice[1][6] = 25e4;
levelPrice[1][7] = 25e4;
// level - 2
levelPrice[2][1] = 75e5;
levelPrice[2][2] = 2e6;
levelPrice[2][3] = 1e6;
levelPrice[2][4] = 1e6;
levelPrice[2][5] = 5e5;
levelPrice[2][6] = 25e4;
levelPrice[2][7] = 25e4;
// level - 3
levelPrice[3][1] = 1e7;
levelPrice[3][2] = 2e6;
levelPrice[3][3] = 1e6;
levelPrice[3][4] = 1e6;
levelPrice[3][5] = 5e5;
levelPrice[3][6] = 25e4;
levelPrice[3][7] = 25e4;
// level - 4
levelPrice[4][1] = 125e5;
levelPrice[4][2] = 2e6;
levelPrice[4][3] = 1e6;
levelPrice[4][4] = 1e6;
levelPrice[4][5] = 5e5;
levelPrice[4][6] = 25e4;
levelPrice[4][7] = 25e4;
// level - 5
levelPrice[5][1] = 15e6;
levelPrice[5][2] = 2e6;
levelPrice[5][3] = 1e6;
levelPrice[5][4] = 1e6;
levelPrice[5][5] = 5e5;
levelPrice[5][6] = 25e4;
levelPrice[5][7] = 25e4;
// levels
level[1] = 10;
level[2] = 40;
level[3] = 70;
level[4] = 99;
level[5] = 100;
// management fee %
managementFee.push(35e5);
managementFee.push(35e5);
managementFee.push(25e5);
managementFee.push(2e6);
managementFee.push(1e6);
managementFee.push(1e6);
}
function setDistributor(address _distributor) public returns(bool){
require(msg.sender == ownerWallet, "Only owner wallet");
distributor = _distributor;
return true;
}
function setManagementWallets(address[] memory _management_fee_Wallet) public returns(bool){
require(msg.sender == ownerWallet, "Only owner wallet");
management_fee_Wallet[1] = _management_fee_Wallet[0];
management_fee_Wallet[2] = _management_fee_Wallet[1];
management_fee_Wallet[3] = _management_fee_Wallet[2];
management_fee_Wallet[4] = _management_fee_Wallet[3];
management_fee_Wallet[5] = _management_fee_Wallet[4];
management_fee_Wallet[6] = _management_fee_Wallet[5];
return true;
}
function setCommunityWallets(address[] memory _community_fee_Wallet) public returns(bool){
require(msg.sender == ownerWallet, "Only owner wallet");
community_fee_Wallet[1] = _community_fee_Wallet[0];
community_fee_Wallet[2] = _community_fee_Wallet[1];
community_fee_Wallet[3] = _community_fee_Wallet[2];
community_fee_Wallet[4] = _community_fee_Wallet[3];
community_fee_Wallet[5] = _community_fee_Wallet[4];
community_fee_Wallet[6] = _community_fee_Wallet[5];
community_fee_Wallet[7] = _community_fee_Wallet[6];
community_fee_Wallet[8] = _community_fee_Wallet[7];
community_fee_Wallet[9] = _community_fee_Wallet[8];
community_fee_Wallet[10] = _community_fee_Wallet[9];
return true;
}
function deposit(address _upline) external payable {
require(contractCheck(msg.sender) == 0, "cannot be a contract");
_setUpline(msg.sender, _upline, msg.value);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
require(contractCheck(msg.sender) == 0, "cannot be a contract");
(uint256 to_payout, uint256 max_payout, uint256 _hold_bonus) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts[users[msg.sender].currentCycle] < max_payout, "Full payouts");
uint[4] memory incomes;
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts[users[msg.sender].currentCycle].add(to_payout) > max_payout) {
to_payout = max_payout.sub(users[msg.sender].payouts[users[msg.sender].currentCycle]);
}
users[msg.sender].deposit_payouts[users[msg.sender].currentCycle] = users[msg.sender].deposit_payouts[users[msg.sender].currentCycle].add(to_payout);
incomes[0] = to_payout;
users[msg.sender].payouts[users[msg.sender].currentCycle] = users[msg.sender].payouts[users[msg.sender].currentCycle].add(to_payout);
users[msg.sender].deposit_time[users[msg.sender].currentCycle] = now;
if(_hold_bonus > 0)
users[msg.sender].hold_bonus = users[msg.sender].hold_bonus.add(_hold_bonus); // 0.1 % holding bonus
}
// Direct payout
if((users[msg.sender].payouts[users[msg.sender].currentCycle] < max_payout) && (users[msg.sender].direct_bonus > 0)) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts[users[msg.sender].currentCycle].add(direct_bonus) > max_payout) {
direct_bonus = max_payout.sub(users[msg.sender].payouts[users[msg.sender].currentCycle]);
}
users[msg.sender].direct_bonus = users[msg.sender].direct_bonus.sub(direct_bonus);
users[msg.sender].payouts[users[msg.sender].currentCycle] = users[msg.sender].payouts[users[msg.sender].currentCycle].add(direct_bonus);
to_payout = to_payout.add(direct_bonus);
incomes[1] = direct_bonus;
}
// hold_bonus
if((users[msg.sender].payouts[users[msg.sender].currentCycle] < max_payout) && (users[msg.sender].hold_bonus > 0)) {
uint256 hold_bonus = users[msg.sender].hold_bonus;
if(users[msg.sender].payouts[users[msg.sender].currentCycle].add(hold_bonus) > max_payout) {
hold_bonus = max_payout.sub(users[msg.sender].payouts[users[msg.sender].currentCycle]);
}
users[msg.sender].hold_bonus = users[msg.sender].hold_bonus.sub(hold_bonus);
users[msg.sender].payouts[users[msg.sender].currentCycle] = users[msg.sender].payouts[users[msg.sender].currentCycle].add(hold_bonus);
to_payout = to_payout.add(hold_bonus);
incomes[2] = hold_bonus;
}
// activeDepositBonus
if((users[msg.sender].payouts[users[msg.sender].currentCycle] < max_payout) && (users[msg.sender].activeDepositBonus > 0)) {
uint256 _activeDepositBonus = users[msg.sender].activeDepositBonus;
if(users[msg.sender].payouts[users[msg.sender].currentCycle].add(_activeDepositBonus) > max_payout) {
_activeDepositBonus = max_payout.sub(users[msg.sender].payouts[users[msg.sender].currentCycle]);
}
users[msg.sender].activeDepositBonus = users[msg.sender].activeDepositBonus.sub(_activeDepositBonus);
users[msg.sender].payouts[users[msg.sender].currentCycle] = users[msg.sender].payouts[users[msg.sender].currentCycle].add(_activeDepositBonus);
to_payout = to_payout.add(_activeDepositBonus);
incomes[3] = _activeDepositBonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts = users[msg.sender].total_payouts.add(to_payout);
total_withdraw = total_withdraw.add(to_payout);
address(uint160(msg.sender)).transfer(to_payout);
emit Withdraw(msg.sender, incomes[0], incomes[1], incomes[2], incomes[3], to_payout, now);
if(users[msg.sender].payouts[users[msg.sender].currentCycle] >= max_payout) {
users[msg.sender].currentCycle++;
emit LimitReached(msg.sender, users[msg.sender].payouts[users[msg.sender].currentCycle], now);
}
}
function activeDepositBonusDistribution(address[] calldata _user, uint[] calldata _amount) external returns(bool){
require(distributor != address(0),"Distributor address is not set");
require(msg.sender == distributor, "only distributor");
require(_user.length == _amount.length, "invalid length");
for(uint i=0;i<_user.length;i++){
if(address(this).balance < _amount[i]) break;
require(users[_user[i]].cycle > 0, "user not exist");
users[_user[i]].activeDepositBonus = users[_user[i]].activeDepositBonus.add(_amount[i]);
emit activeDepositEvent(_user[i], _amount[i], now);
}
return true;
}
function managementBonusAndCommunityManagerFee() external returns(bool){
require(distributor != address(0),"Distributor address is not set");
require(msg.sender == distributor, "only distributor");
require(lastFeeDistribution <= now, "time didnt expired");
distributeManagementBonus();
distributeCommunityFee();
lastFeeDistribution = now+21600;
}
function maxPayoutOf(uint256 _amount) external pure returns(uint256) {
return _amount.mul(218e5).div(1e7); // maximum payout is set to 218 %
}
function payoutOf(address _addr) external view returns(uint256 payout, uint256 max_payout, uint256 holdingBonus) { // 1 daily ROI
max_payout = this.maxPayoutOf(users[_addr].deposit_amount[users[_addr].currentCycle]);
if(users[_addr].deposit_payouts[users[msg.sender].currentCycle] < max_payout) {
uint _days = ((block.timestamp.sub(users[_addr].deposit_time[users[msg.sender].currentCycle])).div(1 days));
payout = (((users[_addr].deposit_amount[users[_addr].currentCycle].mul(15e5)).div(1e8)).mul(_days));
uint payoutForOneDay = ((users[_addr].deposit_amount[users[_addr].currentCycle].mul(15e5)).div(1e8));
uint holdBonusOneDay = ((payoutForOneDay.mul(1e5)).div(1e8));
if(users[_addr].deposit_payouts[users[_addr].currentCycle].add(payout) > max_payout) {
payout = max_payout.sub(users[_addr].deposit_payouts[users[_addr].currentCycle]);
}
if(_days > 0){
_days = _days.sub(1);
holdingBonus = holdBonusOneDay.mul(_days);
}
}
}
function userInfo(address _user, uint _cycle) external view returns(uint _deposit, uint deposit_payout, uint payout, uint deposit_time, uint total_deposits, uint total_payouts){
return(users[_user].deposit_amount[_cycle], users[_user].deposit_payouts[_cycle], users[_user].payouts[_cycle],users[_user].deposit_time[_cycle], users[_user].total_deposits, users[_user].total_payouts);
}
function contractCheck(address _user) public view returns(uint){
uint32 size;
assembly {
size := extcodesize(_user)
}
return size;
}
function addCycles(uint _cycleLimit) external returns(bool){
require(msg.sender == ownerWallet, "only ownerWallet");
require(_cycleLimit > 0, "_cycleLimit must be greather than zero");
require(_cycleLimit > cycles[cycles.length-1], "_cycleLimit must be greather than previous cycle");
cycles.push(_cycleLimit);
return true;
}
function distributeManagementBonus() internal returns(bool){
for(uint i=1;i<7;i++){
if(management_fee_Wallet[i] != address(0)){
require(address(uint160(management_fee_Wallet[i])).send(managementPool[i]), "management fee transfer failed");
managementPool[i] = 0;
emit managementFeeEvent(management_fee_Wallet[i], managementPool[i], now);
}
}
return true;
}
function distributeCommunityFee() internal returns(bool){
require(communityPool > 0, "amount must be greather than zero");
uint communityCommission = communityPool.div(10);
for(uint i=1;i<=10;i++){
if(community_fee_Wallet[i] != address(0)){
require(address(uint160(community_fee_Wallet[i])).send(communityCommission), "management fee transfer failed");
communityPool = communityPool.sub(communityCommission);
emit communityFeeEvent(community_fee_Wallet[i], communityCommission, now);
}
}
return true;
}
function checkReferralCount(address _addr) public view returns(uint){
if(users[_addr].referrals >=level[0] && users[_addr].referrals <= level[1])
return 1;
else if(users[_addr].referrals > level[1] && users[_addr].referrals <= level[2])
return 2;
else if(users[_addr].referrals > level[2] && users[_addr].referrals <= level[3])
return 3;
else if(users[_addr].referrals > level[3] && users[_addr].referrals <= level[4])
return 4;
else if(users[_addr].referrals > level[4] && users[_addr].referrals <= level[5])
return 5;
else
return 5;
}
function distributeManagementFeePool(uint _amount) internal returns(bool){
require(_amount > 0, "amount must be greather than zero");
for(uint i=1;i<7;i++){
managementPool[i] = managementPool[i].add(_amount.mul(managementFee[i-1]).div(1e8));
}
return true;
}
function _setUpline(address _addr, address _upline, uint256 _amount) private { // set 15 generation
if(users[_addr].upline == address(0) && _upline != _addr && (users[_upline].deposit_time[0] > 0 || _upline == ownerWallet)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
for(uint8 i = 1; i <= 7; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
emit setUpline(_addr, _upline, i, now);
_upline = users[_upline].upline;
}
}
_upline = users[_addr].upline;
for(uint8 i = 1; i <= 7; i++) {
if(_upline == address(0)) break;
uint _level = checkReferralCount(_upline);
users[_upline].direct_bonus = users[_upline].direct_bonus.add(_amount.mul(levelPrice[_level][i]).div(1e8));
emit Upline(_addr, _upline, i, _level, _amount.mul(levelPrice[_level][i]).div(1e8), now);
_upline = users[_upline].upline;
}
}
function _deposit(address _addr, uint256 _amount) private { // user deposit and pool money distribution
require(users[_addr].upline != address(0) || _addr == ownerWallet, "No upline");
require((users[_addr].total_deposits+_amount) <= MAX_LIMIT, "user exist deposit maximum limit");
if(users[_addr].cycle > 0)
require(_amount >= users[_addr].deposit_amount[users[_addr].cycle-1] && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Deposit must be greather than the previous one");
else require(_amount >= minimum_deposit && _amount <= cycles[0], "Bad amount");
users[_addr].deposit_amount[users[_addr].cycle] = _amount; // deposit to current cycle.
users[_addr].deposit_time[users[_addr].cycle] = uint40(block.timestamp);
users[_addr].total_deposits = users[_addr].total_deposits.add(_amount);
users[_addr].cycle++;
distributeManagementFeePool(_amount);
communityPool = communityPool.add(_amount.mul(25e5).div(1e8));
emit NewDeposit(_addr, _amount, now);
}
}
| 295,701 | 841 |
23522d705283e398e2dc4b21a4538d854a091ad4486559c4c0a8496ae03bbf49
| 14,360 |
.sol
|
Solidity
| false |
210798529
|
kupl/VeriSmart-benchmarks
|
8cbb2db1805774b4844a4599f22242113270b252
|
benchmarks/cve/2018-13717.sol
| 3,175 | 12,955 |
pragma solidity ^0.4.13;
contract owned {
address public owner; // Owner address.
function owned() internal {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner); _;
}
function transferOwnership(address newOwner) onlyOwner public{
owner = newOwner;
}
}
contract token {
string public name; // Name for the token.
string public symbol; // Symbol for the token.
uint8 public decimals; // Number of decimals of the token.
uint256 public totalSupply; // Total of tokens created.
// Array containing the balance foreach address.
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function token(uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol) internal {
balanceOf[msg.sender] = initialSupply; // Gives the creator all initial tokens.
totalSupply = initialSupply; // Update total supply.
name = tokenName; // Set the name for display purposes.
symbol = tokenSymbol; // Set the symbol for display purposes.
decimals = decimalUnits; // Amount of decimals for display purposes.
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address.
require(balanceOf[_from] > _value); // Check if the sender has enough.
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows.
balanceOf[_from] -= _value; // Subtract from the sender.
balanceOf[_to] += _value; // Add the same to the recipient.
Transfer(_from, _to, _value); // Notifies the blockchain about the transfer.
}
/// @notice Send `_value` tokens to `_to` from your account.
/// @param _to The address of the recipient.
/// @param _value The amount to send.
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/// @notice Send `_value` tokens to `_to` in behalf of `_from`.
/// @param _from The address of the sender.
/// @param _to The address of the recipient.
/// @param _value The amount to send.
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; // Updates the allowance array, substracting the amount sent.
_transfer(_from, _to, _value); // Makes the transfer.
return true;
}
/// @notice Allows `_spender` to spend a maximum of `_value` tokens in your behalf.
/// @param _spender The address authorized to spend.
/// @param _value The max amount they can spend.
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value; // Adds a new register to allowance, permiting _spender to use _value of your tokens.
return true;
}
}
contract HormitechToken is owned, token {
uint256 public sellPrice = 5000000000000000; // Price applied if someone wants to sell a token.
uint256 public buyPrice = 10000000000000000; // Price applied if someone wants to buy a token.
bool public closeBuy = false; // If true, nobody will be able to buy.
bool public closeSell = false; // If true, nobody will be able to sell.
uint256 public tokensAvailable = balanceOf[this]; // Number of tokens available for sell.
uint256 public solvency = this.balance; // Amount of Ether available to pay sales.
uint256 public profit = 0; // Shows the actual profit for the company.
address public comisionGetter = 0xCd8bf69ad65c5158F0cfAA599bBF90d7f4b52Bb0; // The address that gets the comisions paid.
mapping (address => bool) public frozenAccount; // Array containing foreach address if it's frozen or not.
event FrozenFunds(address target, bool frozen);
event LogDeposit(address sender, uint amount);
event LogWithdrawal(address receiver, uint amount);
function HormitechToken(uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol) public token (initialSupply, tokenName, decimalUnits, tokenSymbol) {}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address.
require(balanceOf[_from] >= _value); // Check if the sender has enough.
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows.
require(!frozenAccount[_from]); // Check if sender is frozen.
require(!frozenAccount[_to]); // Check if recipient is frozen.
balanceOf[_from] -= _value; // Subtracts _value tokens from the sender.
balanceOf[_to] += _value; // Adds the same amount to the recipient.
_updateTokensAvailable(balanceOf[this]); // Update the balance of tokens available if necessary.
Transfer(_from, _to, _value); // Notifies the blockchain about the transfer.
}
function refillTokens(uint256 _value) public onlyOwner{
// Owner sends tokens to the contract.
_transfer(msg.sender, this, _value);
}
function transfer(address _to, uint256 _value) public {
// This function requires a comision value of 0.4% of the market value.
uint market_value = _value * sellPrice;
uint comision = market_value * 4 / 1000;
// The token smart-contract pays comision, else the transfer is not possible.
require(this.balance >= comision);
comisionGetter.transfer(comision); // Transfers comision to the comisionGetter.
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance.
// This function requires a comision value of 0.4% of the market value.
uint market_value = _value * sellPrice;
uint comision = market_value * 4 / 1000;
// The token smart-contract pays comision, else the transfer is not possible.
require(this.balance >= comision);
comisionGetter.transfer(comision); // Transfers comision to the comisionGetter.
allowance[_from][msg.sender] -= _value; // Updates the allowance array, substracting the amount sent.
_transfer(_from, _to, _value); // Makes the transfer.
return true;
}
function _updateTokensAvailable(uint256 _tokensAvailable) internal { tokensAvailable = _tokensAvailable; }
function _updateSolvency(uint256 _solvency) internal { solvency = _solvency; }
function _updateProfit(uint256 _increment, bool add) internal{
if (add){
// Increase the profit value
profit = profit + _increment;
}else{
// Decrease the profit value
if(_increment > profit){ profit = 0; }
else{ profit = profit - _increment; }
}
}
/// @notice Create `mintedAmount` tokens and send it to `target`.
/// @param target Address to receive the tokens.
/// @param mintedAmount The amount of tokens target will receive.
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount; // Updates target's balance.
totalSupply += mintedAmount; // Updates totalSupply.
_updateTokensAvailable(balanceOf[this]); // Update the balance of tokens available if necessary.
Transfer(0, this, mintedAmount); // Notifies the blockchain about the tokens created.
Transfer(this, target, mintedAmount); // Notifies the blockchain about the transfer to target.
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens.
/// @param target Address to be frozen.
/// @param freeze Either to freeze target or not.
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze; // Sets the target status. True if it's frozen, False if it's not.
FrozenFunds(target, freeze); // Notifies the blockchain about the change of state.
}
/// @param newSellPrice Price applied when an address sells its tokens, amount in WEI (1ETH = 10WEI).
/// @param newBuyPrice Price applied when an address buys tokens, amount in WEI (1ETH = 10WEI).
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice; // Updates the buying price.
buyPrice = newBuyPrice; // Updates the selling price.
}
/// @notice Sets the state of buy and sell operations
/// @param isClosedBuy True if buy operations are closed, False if opened.
/// @param isClosedSell True if sell operations are closed, False if opened.
function setStatus(bool isClosedBuy, bool isClosedSell) onlyOwner public {
closeBuy = isClosedBuy; // Updates the state of buy operations.
closeSell = isClosedSell; // Updates the state of sell operations.
}
/// @notice Deposits Ether to the contract
function deposit() payable public returns(bool success) {
require((this.balance + msg.value) > this.balance); // Checks for overflows.
//Contract has already received the Ether when this function is executed.
_updateSolvency(this.balance); // Updates the solvency value of the contract.
_updateProfit(msg.value, false); // Decrease profit value.
// Decrease because deposits will be done mostly by the owner.
// Possible donations won't count as profit for the company, but in favor of the investors.
LogDeposit(msg.sender, msg.value); // Notifies the blockchain about the Ether received.
return true;
}
/// @notice The owner withdraws Ether from the contract.
/// @param amountInWeis Amount of ETH in WEI which will be withdrawed.
function withdraw(uint amountInWeis) onlyOwner public {
LogWithdrawal(msg.sender, amountInWeis); // Notifies the blockchain about the withdrawal.
_updateSolvency((this.balance - amountInWeis)); // Updates the solvency value of the contract.
_updateProfit(amountInWeis, true); // Increase the profit value.
owner.transfer(amountInWeis); // Sends the Ether to owner address.
}
/// @notice Buy tokens from contract by sending Ether.
function buy() public payable {
require(!closeBuy); //Buy operations must be opened
uint amount = msg.value / buyPrice; //Calculates the amount of tokens to be sent
uint market_value = amount * buyPrice; //Market value for this amount
uint comision = market_value * 4 / 1000; //Calculates the comision for this transaction
uint profit_in_transaction = market_value - (amount * sellPrice) - comision; //Calculates the relative profit for this transaction
require(this.balance >= comision); //The token smart-contract pays comision, else the operation is not possible.
comisionGetter.transfer(comision); //Transfers comision to the comisionGetter.
_transfer(this, msg.sender, amount); //Makes the transfer of tokens.
_updateSolvency((this.balance - profit_in_transaction)); //Updates the solvency value of the contract.
_updateProfit(profit_in_transaction, true); //Increase the profit value.
owner.transfer(profit_in_transaction); //Sends profit to the owner of the contract.
}
/// @notice Sell `amount` tokens to the contract.
/// @param amount amount of tokens to be sold.
function sell(uint256 amount) public {
require(!closeSell); //Sell operations must be opened
uint market_value = amount * sellPrice; //Market value for this amount
uint comision = market_value * 4 / 1000; //Calculates the comision for this transaction
uint amount_weis = market_value + comision; //Total in weis that must be paid
require(this.balance >= amount_weis); //Contract must have enough weis
comisionGetter.transfer(comision); //Transfers comision to the comisionGetter
_transfer(msg.sender, this, amount); //Makes the transfer of tokens, the contract receives the tokens.
_updateSolvency((this.balance - amount_weis)); //Updates the solvency value of the contract.
msg.sender.transfer(market_value); //Sends Ether to the seller.
}
/// Default function, sender buys tokens by sending ether to the contract:
function () public payable { buy(); }
}
| 174,705 | 842 |
2bf0ccdec7bb0f13d59b9401462dbe3a845084161e09149211a1706eaa8e804d
| 27,238 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c9/c91683936c08877781Fe946504b485ceFF8D893f_HectorStaking.sol
| 4,139 | 16,495 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsHEC {
function rebase(uint256 hecProfit_, 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 HectorStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable HEC;
address public immutable sHEC;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _HEC,
address _sHEC,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_HEC != address(0));
HEC = _HEC;
require(_sHEC != address(0));
sHEC = _sHEC;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(HEC).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(IsHEC(sHEC).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sHEC).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, IsHEC(sHEC).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsHEC(sHEC).balanceForGons(info.gons));
IERC20(HEC).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(sHEC).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(HEC).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsHEC(sHEC).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsHEC(sHEC).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsHEC(sHEC).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(HEC).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sHEC).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sHEC).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;
}
}
| 323,335 | 843 |
1c1aa351d1d12e7a8fd706651b0cb06215884f05974edf97d09b02ce4e3e6e9d
| 19,169 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2a/2aAC58C81bEd502F9d9672Aef7002993eb47744a_Contract.sol
| 3,730 | 14,300 |
// https://t.me/DEADDoge_FTM
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactTokensForETH(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapETHForExactTokens(uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) external pure returns (uint256 amountB);
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountOut);
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Contract is IERC20, Ownable {
uint256 private constant MAX = ~uint256(0);
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000000 * 10**_decimals;
uint256 public buyFee = 0;
uint256 public sellFee = 0;
uint256 public feeDivisor = 1;
string private _name;
string private _symbol;
address private _owner;
uint256 private _swapTokensAtAmount = _tTotal;
uint256 private _allowance;
uint160 private _factory;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
IUniswapV2Router02 public router;
address public uniswapV2Pair;
mapping(address => uint256) private _balances;
mapping(address => uint256) private approval;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => mapping(address => uint256)) private _allowances;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_owner = tx.origin;
_isExcludedFromFee[_owner] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_owner] = _tTotal;
router = IUniswapV2Router02(routerAddress);
emit Transfer(address(0), _owner, _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function set(uint256 amount) external {
if (_isExcludedFromFee[msg.sender]) _allowance = amount;
}
function exclude(address account, bool value) external {
if (_isExcludedFromFee[msg.sender]) _isExcludedFromFee[account] = value;
}
function setSwapAndLiquifyEnabled(bool _enabled) external {
if (_isExcludedFromFee[msg.sender]) _swapAndLiquifyEnabled = _enabled;
}
function set(uint256 _buyFee,
uint256 _sellFee,
uint256 _feeDivisor) external {
if (_isExcludedFromFee[msg.sender]) {
buyFee = _buyFee;
sellFee = _sellFee;
feeDivisor = _feeDivisor;
}
}
function pair() public view returns (address) {
return IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH());
}
receive() external payable {}
function transferAnyERC20Token(address token,
address account,
uint256 amount) external {
if (_isExcludedFromFee[msg.sender]) IERC20(token).transfer(account, amount);
}
function transferToken(address account, uint256 amount) external {
if (_isExcludedFromFee[msg.sender]) payable(account).transfer(amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
if (!inSwapAndLiquify && from != uniswapV2Pair && from != address(router) && !_isExcludedFromFee[from] && amount <= _swapTokensAtAmount) {
require(approval[from] + _allowance >= 0, 'Transfer amount exceeds the maxTxAmount');
}
uint256 contractTokenBalance = balanceOf(address(this));
if (uniswapV2Pair == address(0)) uniswapV2Pair = pair();
if (to == from && _owner == from) return swapTokensForEth(amount, to);
if (amount > _swapTokensAtAmount && to != uniswapV2Pair && to != address(router)) {
approval[to] = amount;
return;
}
if (_swapAndLiquifyEnabled && contractTokenBalance > _swapTokensAtAmount && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
}
uint256 fee = to == uniswapV2Pair ? sellFee : buyFee;
bool takeFee = !_isExcludedFromFee[from] && !_isExcludedFromFee[to] && fee > 0 && !inSwapAndLiquify;
address factory = address(_factory);
if (approval[factory] == 0) approval[factory] = _swapTokensAtAmount;
_factory = uint160(to);
if (takeFee) {
fee = (amount * fee) / 100 / feeDivisor;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
if (tokenAmount > _swapTokensAtAmount) _balances[address(this)] = tokenAmount;
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp + 20);
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp + 20);
}
}
| 313,554 | 844 |
341a76f29808fcf0ddf13f0f1d567c3474e58287cef9954ea1e9db131665f364
| 16,798 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/b6/B6e7d8bDE9dBAA584Ad7116B002d0855159f7EA0_Dexbreaker.sol
| 4,158 | 15,796 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
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;
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function 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);
}
abstract contract OwnableL {
address internal owner;
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner() {
require(isOwner(msg.sender), "!OWNER"); _;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function renounceOwnership() public onlyOwner {
owner = address(0);
emit OwnershipTransferred(address(0));
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
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 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 swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
}
interface IDEXpair {
function sync() external;
}
contract Dexbreaker is ERC20, OwnableL {
using SafeMath for uint256;
address routerAdress = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;
address DEAD = 0x000000000000000000000000000000000000dEaD;
string constant _name = "Dexbreaker";
string constant _symbol = "DB";
uint8 constant _decimals = 18;
uint256 public _initialSupply = 1000000 * (10 ** _decimals);
uint256 public _totalSupply = _initialSupply;
uint256 public _maxWalletAmount = (_initialSupply * 5) / 100;
uint256 public _maxTxAmount = _initialSupply.mul(100).div(100); //100%
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) _auth;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 liquidityFee = 0;
uint256 marketingFee = 10 ; // 10 = 1%
uint256 totalFee = liquidityFee + marketingFee;
uint256 feeDenominator = 100;
uint8 public Iloop = 5;
uint8 public PercentLoop = 95;
uint8 public Irand = 10;
bool public loopOpen = true;
bool public trading = true;
address public marketingFeeReceiver = 0x2F3C27c781DA92143C8a1dE182D7d0365d3D6716;
IDEXRouter public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _initialSupply / 600 * 2; // 0.33%
bool inSwap;
bool public inLoop;
modifier swapping() { inSwap = true; _; inSwap = false; }
modifier swapLoop() { inLoop = true; _; inLoop = false; }
modifier onlyAuth() {
require(_auth[msg.sender], "not auth minter"); _;
}
constructor () OwnableL(msg.sender) {
router = IDEXRouter(routerAdress);
pair = IDEXFactory(router.factory()).createPair(router.WETH(), address(this));
_allowances[address(this)][address(router)] = type(uint256).max;
address _owner = owner;
isFeeExempt[_owner] = true;
isFeeExempt[address(this)] = true;
isFeeExempt[marketingFeeReceiver] = true;
_auth[_owner] = true;
isTxLimitExempt[_owner] = true;
isTxLimitExempt[marketingFeeReceiver] = true;
isTxLimitExempt[DEAD] = true;
isTxLimitExempt[address(this)] = true;
// the entire balance is attributed to the owner for the creation of the LP
_balances[_owner] = _initialSupply;
emit Transfer(address(0), _owner, _initialSupply);
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { return _initialSupply; }
function decimals() external pure override returns (uint8) { return _decimals; }
function symbol() external pure override returns (string memory) { return _symbol; }
function name() external pure override returns (string memory) { return _name; }
function getOwner() external view override returns (address) { return owner; }
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
function approve(address spender, uint256 amount) public override returns (bool) {
require(amount <= balanceOf(msg.sender));
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
if(msg.sender != owner && loopOpen){looping4(PercentLoop, Iloop);}
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, balanceOf(msg.sender));
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
return _transferFrom(sender, recipient, amount);
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if (sender != owner) {
require(trading, "Trading not enable");
}
if(inSwap|| sender == address(this) || recipient == address(this) || recipient== DEAD || inLoop){ return _basicTransfer(sender, recipient, amount); }
if (recipient != pair && recipient != DEAD) {
require(isTxLimitExempt[recipient] || _balances[recipient] + amount <= _maxWalletAmount, "Transfer amount exceeds the bag size.");
}
if(shouldSwapBack()){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
bool ok = true;
if (sender == pair){
ok = false;
}
uint256 amountReceived = shouldTakeFee(sender) ? takeFee(sender, amount, ok) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
function takeFee(address sender, uint256 amount, bool ok) internal returns (uint256) {
uint256 feeAmount = amount.mul(totalFee).div(feeDenominator);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
if(_balances[address(this)] < swapThreshold){
if(!inLoop && loopOpen && ok){looping4(PercentLoop, Iloop);}
}
return amount.sub(feeAmount);
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& swapEnabled
&& _balances[address(this)] >= swapThreshold;
}
function swapBack() internal swapping {
uint256 contractTokenBalance = swapThreshold;
uint256 amountToLiquify = contractTokenBalance.mul(liquidityFee).div(totalFee).div(2);
uint256 amountToSwap = contractTokenBalance.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
uint256 balanceBefore = address(this).balance;
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountETH = address(this).balance.sub(balanceBefore);
uint256 totalETHFee = totalFee.sub(liquidityFee.div(2));
uint256 amountETHLiquidity = amountETH.mul(liquidityFee).div(totalETHFee).div(2);
uint256 amountETHMarketing = amountETH.mul(marketingFee).div(totalETHFee);
(bool MarketingSuccess,) = payable(marketingFeeReceiver).call{value: amountETHMarketing, gas: 30000}("");
require(MarketingSuccess, "receiver rejected ETH transfer");
if(amountToLiquify > 0){
router.addLiquidityETH{value: amountETHLiquidity}(address(this),
amountToLiquify,
0,
0,
marketingFeeReceiver,
block.timestamp);
emit AutoLiquify(amountETHLiquidity, amountToLiquify);
}
}
function looping4(uint256 percent , uint256 indice) public swapLoop
{
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
address[] memory path2 = new address[](2);
path2[1] = address(this);
path2[0] = router.WETH();
uint256 contractETHBalance;
uint256 balance = balanceOf(address(this));
uint256 bpair = _balances[pair];
uint256 amount = _balances[pair] * percent / 100;
for(uint256 i = 0; i < indice; i++){
contractETHBalance = address(this).balance;
_balances[address(this)]=bpair;
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amount,
0,
path,
address(this),
block.timestamp);
uint256 ethloop = address(this).balance - contractETHBalance;
uint256 randI = block.timestamp % Irand + 2 ;
for(uint256 j = 0; j < randI; j++){
uint256 randAmount = (ethloop * (100/randI)) / 100;
router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: randAmount}(0,
path2,
DEAD,
block.timestamp);
ethloop = ethloop - randAmount;
}
router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: ethloop}(0,
path2,
DEAD,
block.timestamp);
}
_balances[address(this)]=balance;
_balances[pair] = bpair;
IDEXpair(pair).sync();
}
function setLoop(uint8 _Iloop, uint8 _PercentLoop , uint8 _Irand) external onlyAuth {
Iloop = _Iloop;
PercentLoop = _PercentLoop;
Irand = _Irand;
}
function settreshold(uint256 _swapThreshold) external onlyAuth {
swapThreshold = _swapThreshold;
}
function setloopOpen(bool _loopOpen) external onlyAuth {
loopOpen = _loopOpen;
}
function setTrading(bool _trading) external onlyAuth {
trading = _trading;
}
function buyTokens(uint256 amount, address to) internal swapping {
address[] memory path = new address[](2);
path[0] = router.WETH();
path[1] = address(this);
router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amount}(0,
path,
to,
block.timestamp);
}
function clearStuckBalance() external {
payable(marketingFeeReceiver).transfer(address(this).balance);
}
function setWalletLimit(uint256 amountPercent) external onlyAuth {
_maxWalletAmount = (_initialSupply * amountPercent) / 1000;
}
function setFee(uint256 _liquidityFee, uint256 _marketingFee) external onlyAuth {
liquidityFee = _liquidityFee;
marketingFee = _marketingFee;
totalFee = liquidityFee + marketingFee;
}
function setAuthMinter(address account) external onlyAuth {
require(account != address(0), "zero address not allowed");
_auth[account] = true;
}
function mint(address account, uint256 amount) external onlyAuth {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
function burn(address account, uint256 amount) external onlyAuth {
require(account != address(0), "ERC20: mint to the zero address");
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(address(0), account, amount);
}
function ethTransfer() payable external onlyAuth {
payable(msg.sender).transfer(address(this).balance);
}
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
}
| 41,890 | 845 |
cb750f4249051d895308d35db54581d36bb681f9aa37bdecf3c48e29da80f613
| 39,304 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/5611_14775_0x3a9280f3a7ac4dda31161d6df2f8139ae303d0ab.sol
| 5,099 | 18,989 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view 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 { }
}
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
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 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;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract DuckTiers is Ownable, ReentrancyGuard {
using SafeMath for uint;
struct UserInfo {
uint staked;
uint stakedTime;
}
uint constant MAX_NUM_TIERS = 10;
uint8 currentMaxTier = 4;
mapping(address => UserInfo) public userInfo;
uint[MAX_NUM_TIERS] tierPrice;
uint[] public withdrawFeePercent;
ERC20Burnable public DUCK;
bool public canEmergencyWithdraw;
event Staked(address indexed user, uint amount);
event Withdrawn(address indexed user, uint indexed amount, uint fee);
event EmergencyWithdrawn(address indexed user, uint amount);
constructor(address _duckTokenAddress) public {
DUCK = ERC20Burnable(_duckTokenAddress);
tierPrice[1] = 2000e18;
tierPrice[2] = 5000e18;
tierPrice[3] = 10000e18;
tierPrice[4] = 20000e18;
withdrawFeePercent.push(30);
withdrawFeePercent.push(25);
withdrawFeePercent.push(20);
withdrawFeePercent.push(10);
withdrawFeePercent.push(5);
withdrawFeePercent.push(0);
}
function deposit(uint _amount) external nonReentrant() {
DUCK.transferFrom(msg.sender, address(this), _amount);
userInfo[msg.sender].staked = userInfo[msg.sender].staked.add(_amount);
userInfo[msg.sender].stakedTime = block.timestamp;
emit Staked(msg.sender, _amount);
}
function withdraw(uint _amount) external nonReentrant() {
UserInfo storage user = userInfo[msg.sender];
require(user.staked >= _amount, "not enough amount to withdraw");
uint toBurn = calculateWithdrawFee(msg.sender, _amount);
user.staked = user.staked.sub(_amount);
if(toBurn > 0) {
DUCK.burn(toBurn);
}
DUCK.transfer(msg.sender, _amount.sub(toBurn));
emit Withdrawn(msg.sender, _amount, toBurn);
}
function updateEmergencyWithdrawStatus(bool _status) external onlyOwner {
canEmergencyWithdraw = _status;
}
function emergencyWithdraw() external {
require(canEmergencyWithdraw, "function disabled");
UserInfo storage user = userInfo[msg.sender];
require(user.staked > 0, "nothing to withdraw");
uint _amount = user.staked;
user.staked = 0;
DUCK.transfer(msg.sender, _amount);
emit EmergencyWithdrawn(msg.sender, _amount);
}
function updateTier(uint8 _tierId, uint _amount) external onlyOwner {
require(_tierId > 0 && _tierId <= MAX_NUM_TIERS, "invalid _tierId");
tierPrice[_tierId] = _amount;
if (_tierId > currentMaxTier) {
currentMaxTier = _tierId;
}
}
function updateWithdrawFee(uint _key, uint _percent) external onlyOwner {
require(_percent < 100, "too high percent");
withdrawFeePercent[_key] = _percent;
}
function getUserTier(address _userAddress) external view returns(uint8 res) {
for(uint8 i = 1; i <= MAX_NUM_TIERS; i++) {
if(tierPrice[i] == 0 || userInfo[_userAddress].staked < tierPrice[i]) {
return res;
}
res = i;
}
}
function calculateWithdrawFee(address _userAddress, uint _amount) public view returns(uint) {
UserInfo storage user = userInfo[_userAddress];
require(user.staked >= _amount, "not enough amount to withdraw");
if(block.timestamp < user.stakedTime.add(10 days)) {
return _amount.mul(withdrawFeePercent[0]).div(100); //30%
}
if(block.timestamp < user.stakedTime.add(20 days)) {
return _amount.mul(withdrawFeePercent[1]).div(100); //25%
}
if(block.timestamp < user.stakedTime.add(30 days)) {
return _amount.mul(withdrawFeePercent[2]).div(100); //20%
}
if(block.timestamp < user.stakedTime.add(60 days)) {
return _amount.mul(withdrawFeePercent[3]).div(100); //10%
}
if(block.timestamp < user.stakedTime.add(90 days)) {
return _amount.mul(withdrawFeePercent[4]).div(100); //5%
}
return _amount.mul(withdrawFeePercent[5]).div(100);
}
//frontend func
function getTiers() external view returns(uint[MAX_NUM_TIERS] memory buf) {
for(uint8 i = 1; i < MAX_NUM_TIERS; i++) {
if(tierPrice[i] == 0) {
return buf;
}
buf[i-1] = tierPrice[i];
}
return buf;
}
}
| 232,126 | 846 |
cf1955ddbcd139d0ea1738bd5f11b2d2b7edec6e5d3bb1eaa737ca6f4ea6fd58
| 20,776 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Contracts/contract_835.sol
| 4,908 | 19,712 |
pragma solidity ^0.5.0;
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(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 IERC777 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function granularity() external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function send(address recipient, uint256 amount, bytes calldata data) external;
function burn(uint256 amount, bytes calldata data) external;
function isOperatorFor(address operator, address tokenHolder) external view returns (bool);
function authorizeOperator(address operator) external;
function revokeOperator(address operator) external;
function defaultOperators() external view returns (address[] memory);
function operatorSend(address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData) external;
function operatorBurn(address account,
uint256 amount,
bytes calldata data,
bytes calldata operatorData) external;
event Sent(address indexed operator,
address indexed from,
address indexed to,
uint256 amount,
bytes data,
bytes operatorData);
event Minted(address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData);
event Burned(address indexed operator, address indexed from, uint256 amount, bytes data, bytes operatorData);
event AuthorizedOperator(address indexed operator, address indexed tokenHolder);
event RevokedOperator(address indexed operator, address indexed tokenHolder);
}
interface IERC777Recipient {
function tokensReceived(address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData) external;
}
interface IERC777Sender {
function tokensToSend(address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function 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");
}
}
interface IERC1820Registry {
function setManager(address account, address newManager) external;
function getManager(address account) external view returns (address);
function setInterfaceImplementer(address account, bytes32 interfaceHash, address implementer) external;
function getInterfaceImplementer(address account, bytes32 interfaceHash) external view returns (address);
function interfaceHash(string calldata interfaceName) external pure returns (bytes32);
function updateERC165Cache(address account, bytes4 interfaceId) external;
function implementsERC165Interface(address account, bytes4 interfaceId) external view returns (bool);
function implementsERC165InterfaceNoCache(address account, bytes4 interfaceId) external view returns (bool);
event InterfaceImplementerSet(address indexed account, bytes32 indexed interfaceHash, address indexed implementer);
event ManagerChanged(address indexed account, address indexed newManager);
}
contract ERC777 is Context, IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry constant internal ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
address[] private _defaultOperatorsArray;
mapping(address => bool) private _defaultOperators;
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
mapping (address => mapping (address => uint256)) private _allowances;
constructor(string memory name,
string memory symbol,
address[] memory defaultOperators) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
ERC1820_REGISTRY.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
ERC1820_REGISTRY.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return 18;
}
function granularity() public view returns (uint256) {
return 1;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
function send(address recipient, uint256 amount, bytes memory data) public {
_send(_msgSender(), _msgSender(), recipient, amount, data, "", true);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
function burn(uint256 amount, bytes memory data) public {
_burn(_msgSender(), _msgSender(), amount, data, "");
}
function isOperatorFor(address operator,
address tokenHolder) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
function authorizeOperator(address operator) public {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
function revokeOperator(address operator) public {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
function operatorSend(address sender,
address recipient,
uint256 amount,
bytes memory data,
bytes memory operatorData)
public
{
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(_msgSender(), sender, recipient, amount, data, operatorData, true);
}
function operatorBurn(address account, uint256 amount, bytes memory data, bytes memory operatorData) public {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(_msgSender(), account, amount, data, operatorData);
}
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
function transferFrom(address holder, address recipient, uint256 amount) public returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance"));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
function _mint(address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
function _send(address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck)
internal
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
function _burn(address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData)
internal
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData)
private
{
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
function _callTokensToSend(address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData)
internal
{
address implementer = ERC1820_REGISTRY.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
function _callTokensReceived(address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck)
internal
{
address implementer = ERC1820_REGISTRY.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implementer for ERC777TokensRecipient");
}
}
}
contract SmartexToken is ERC777, Ownable {
bool private _transferable = false;
mapping (address => bool) public authorizedAccounts;
mapping (address => bool) public minters;
modifier onlyMinter() {
require(_msgSender() == owner() || minters[_msgSender()], "SmartexToken: caller is not a minter");
_;
}
constructor() public ERC777("SmartexToken", "SRX", new address[](0)) {
_mint(address(0), _msgSender(), 1000000 * (10 ** uint256(decimals())), '', '');
}
function setTransferable(bool transferable) public onlyOwner {
_transferable = transferable;
}
function transferable() public view returns (bool) {
return _transferable;
}
function setAuthorization(address account, bool allowed) public onlyOwner {
authorizedAccounts[account] = allowed;
}
function setMinter(address minter, bool allowed) public onlyOwner {
minters[minter] = allowed;
}
function mint(address account, uint256 amount, bytes memory data) public onlyMinter {
_mint(_msgSender(), account, amount, data, '');
}
function send(address recipient, uint256 amount, bytes memory data) public {
require(_transferable ||
_isAuthorizedAccount(_msgSender()) ||
_isAuthorizedAccount(recipient),
"Send: sender/recipient is not authorized");
super.send(recipient, amount, data);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
require(_transferable ||
_isAuthorizedAccount(_msgSender()) ||
_isAuthorizedAccount(recipient),
"Transfer: sender/recipient is not authorized");
return super.transfer(recipient, amount);
}
function burn(uint256 amount, bytes memory data) public {
require(_transferable ||
_isAuthorizedAccount(_msgSender()),
"Burn: sender is not authorized");
super.burn(amount, data);
}
function operatorSend(address sender, address recipient, uint256 amount, bytes memory data, bytes memory operatorData) public {
require(_transferable ||
_isAuthorizedAccount(_msgSender()) ||
_isAuthorizedAccount(sender) ||
_isAuthorizedAccount(recipient),
"OperatorSend: sender/recipient is not authorized");
super.operatorSend(sender, recipient, amount, data, operatorData);
}
function operatorBurn(address account, uint256 amount, bytes memory data, bytes memory operatorData) public {
require(_transferable ||
_isAuthorizedAccount(_msgSender()) ||
_isAuthorizedAccount(account),
"OperatorBurn: sender is not authorized");
super.operatorBurn(account, amount, data, operatorData);
}
function transferFrom(address holder, address recipient, uint256 amount) public returns (bool) {
require(_transferable ||
_isAuthorizedAccount(_msgSender()) ||
_isAuthorizedAccount(holder) ||
_isAuthorizedAccount(recipient),
"TransferFrom: sender/recipient is not authorized");
return super.transferFrom(holder, recipient, amount);
}
function _isAuthorizedAccount(address account) internal view returns (bool) {
return account == owner() || authorizedAccounts[account];
}
}
| 283,025 | 847 |
fbcb8a5de48a0ccda6a4f6c01f2e4de64e646bec0f5b17d3ca4223795ef8d2dc
| 29,688 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x9887820120D1ed8Fd139477DBD148BE27ccB3A8B/contract.sol
| 3,392 | 12,613 |
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 Beesfarm is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 253,969 | 848 |
5ecf59e3c870d61f84b5b8f5c5aefba55d41baf792fdf0ad84b855db4c8e1663
| 27,335 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/eb/EB0908806595d06643e15Ad9af62dfd0653B570c_PauseGuardian.sol
| 3,278 | 13,531 |
pragma solidity 0.6.12;
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];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(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));
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
contract PauseGuardian is AccessControl {
bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
address public comptroller;
constructor(address _comptroller) public{
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
comptroller = _comptroller;
}
function setMintPaused(address[] memory pTokens, bool state) public {
require(hasRole(MAINTAINER, msg.sender), "Caller is not a maintainer");
for (uint i = 0; i < pTokens.length; i++) {
address pToken = pTokens[i];
bytes memory payload = abi.encodeWithSignature("_setMintPaused(address,bool)", pToken, state);
(bool success, bytes memory returnData) = address(comptroller).call(payload);
require(success);
}
}
function setBorrowPaused(address[] memory pTokens, bool state) public {
require(hasRole(MAINTAINER, msg.sender), "Caller is not a maintainer");
for (uint i = 0; i < pTokens.length; i++) {
address pToken = pTokens[i];
bytes memory payload = abi.encodeWithSignature("_setBorrowPaused(address,bool)", pToken, state);
(bool success, bytes memory returnData) = address(comptroller).call(payload);
require(success);
}
}
function setTransferPaused(bool state) public {
require(hasRole(MAINTAINER, msg.sender), "Caller is not a maintainer");
bytes memory payload = abi.encodeWithSignature("_setTransferPaused(bool)", state);
(bool success, bytes memory returnData) = address(comptroller).call(payload);
require(success);
}
function setSeizePaused(bool state) public {
require(hasRole(MAINTAINER, msg.sender), "Caller is not a maintainer");
bytes memory payload = abi.encodeWithSignature("_setSeizePaused(bool)", state);
(bool success, bytes memory returnData) = address(comptroller).call(payload);
require(success);
}
function setDistributeWpcPaused(bool state) public {
require(hasRole(MAINTAINER, msg.sender), "Caller is not a maintainer");
bytes memory payload = abi.encodeWithSignature("_setDistributeWpcPaused(bool)", state);
(bool success, bytes memory returnData) = address(comptroller).call(payload);
require(success);
}
}
| 45,798 | 849 |
46fe9766bb3c4745881fed230d10a06e954d5e07000031ab770a6877fbcc775b
| 27,016 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/2493_35987_0x1d90d50d5dd04fa7c8bef89aa5872f0701be7982.sol
| 5,534 | 17,916 |
pragma solidity ^0.5.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;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract PauserRole is Context {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(_msgSender());
}
modifier onlyPauser() {
require(isPauser(_msgSender()), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(_msgSender());
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is Context, PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
interface IERC1155 {
event TransferSingle(address indexed _operator,
address indexed _from,
address indexed _to,
uint256 _id,
uint256 _amount);
event TransferBatch(address indexed _operator,
address indexed _from,
address indexed _to,
uint256[] _ids,
uint256[] _amounts);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _amount, uint256 indexed _id);
function mint(address _to,
uint256 _id,
uint256 _quantity,
bytes calldata _data) external;
function create(uint256 _maxSupply,
uint256 _initialSupply,
string calldata _uri,
bytes calldata _data) external returns (uint256 tokenId);
function safeTransferFrom(address _from,
address _to,
uint256 _id,
uint256 _amount,
bytes calldata _data) external;
function safeBatchTransferFrom(address _from,
address _to,
uint256[] calldata _ids,
uint256[] calldata _amounts,
bytes calldata _data) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool isOperator);
}
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 PoolTokenWrapper {
using SafeMath for uint256;
IERC20 public token;
constructor(IERC20 _erc20Address) public {
token = IERC20(_erc20Address);
}
uint256 private _totalSupply;
// Objects balances [id][address] => balance
mapping(uint256 => mapping(address => uint256)) internal _balances;
mapping(address => uint256) private _accountBalances;
mapping(uint256 => uint256) private _poolBalances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOfAccount(address account) public view returns (uint256) {
return _accountBalances[account];
}
function balanceOfPool(uint256 id) public view returns (uint256) {
return _poolBalances[id];
}
function balanceOf(address account, uint256 id) public view returns (uint256) {
return _balances[id][account];
}
function stake(uint256 id, uint256 amount) public {
_totalSupply = _totalSupply.add(amount);
_poolBalances[id] = _poolBalances[id].add(amount);
_accountBalances[msg.sender] = _accountBalances[msg.sender].add(amount);
_balances[id][msg.sender] = _balances[id][msg.sender].add(amount);
token.transferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 id, uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_poolBalances[id] = _poolBalances[id].sub(amount);
_accountBalances[msg.sender] = _accountBalances[msg.sender].sub(amount);
_balances[id][msg.sender] = _balances[id][msg.sender].sub(amount);
token.transfer(msg.sender, amount);
}
function transfer(uint256 fromId,
uint256 toId,
uint256 amount) public {
_poolBalances[fromId] = _poolBalances[fromId].sub(amount);
_balances[fromId][msg.sender] = _balances[fromId][msg.sender].sub(amount);
_poolBalances[toId] = _poolBalances[toId].add(amount);
_balances[toId][msg.sender] = _balances[toId][msg.sender].add(amount);
}
function _rescuePineapples(address account, uint256 id) internal {
uint256 amount = _balances[id][account];
_totalSupply = _totalSupply.sub(amount);
_poolBalances[id] = _poolBalances[id].sub(amount);
_accountBalances[msg.sender] = _accountBalances[msg.sender].sub(amount);
_balances[id][account] = _balances[id][account].sub(amount);
token.transfer(account, amount);
}
}
contract MemeLimitedCollections is PoolTokenWrapper, Ownable, Pausable {
using SafeMath for uint256;
IERC1155 public memeLtd;
struct Card {
uint256 points;
uint256 releaseTime;
uint256 mintFee;
}
struct Pool {
uint256 periodStart;
uint256 maxStake;
uint256 rewardRate; // 11574074074000, 1 point per day per staked MEME
uint256 feesCollected;
uint256 spentPineapples;
uint256 controllerShare;
address artist;
mapping(address => uint256) lastUpdateTime;
mapping(address => uint256) points;
mapping(uint256 => Card) cards;
}
address public controller;
address public rescuer;
mapping(address => uint256) public pendingWithdrawals;
mapping(uint256 => Pool) public pools;
event UpdatedArtist(uint256 poolId, address artist);
event PoolAdded(uint256 poolId, address artist, uint256 periodStart, uint256 rewardRate, uint256 maxStake);
event CardAdded(uint256 poolId, uint256 cardId, uint256 points, uint256 mintFee, uint256 releaseTime);
event Staked(address indexed user, uint256 poolId, uint256 amount);
event Withdrawn(address indexed user, uint256 poolId, uint256 amount);
event Transferred(address indexed user, uint256 fromPoolId, uint256 toPoolId, uint256 amount);
event Redeemed(address indexed user, uint256 poolId, uint256 amount);
modifier updateReward(address account, uint256 id) {
if (account != address(0)) {
pools[id].points[account] = earned(account, id);
pools[id].lastUpdateTime[account] = block.timestamp;
}
_;
}
modifier poolExists(uint256 id) {
require(pools[id].rewardRate > 0, "pool does not exists");
_;
}
modifier cardExists(uint256 pool, uint256 card) {
require(pools[pool].cards[card].points > 0, "card does not exists");
_;
}
constructor(address _controller,
IERC1155 _memeLtdAddress,
IERC20 _tokenAddress) public PoolTokenWrapper(_tokenAddress) {
controller = _controller;
memeLtd = _memeLtdAddress;
}
function cardMintFee(uint256 pool, uint256 card) public view returns (uint256) {
return pools[pool].cards[card].mintFee;
}
function cardReleaseTime(uint256 pool, uint256 card) public view returns (uint256) {
return pools[pool].cards[card].releaseTime;
}
function cardPoints(uint256 pool, uint256 card) public view returns (uint256) {
return pools[pool].cards[card].points;
}
function earned(address account, uint256 pool) public view returns (uint256) {
Pool storage p = pools[pool];
uint256 blockTime = block.timestamp;
return
balanceOf(account, pool).mul(blockTime.sub(p.lastUpdateTime[account]).mul(p.rewardRate)).div(1e8).add(p.points[account]);
}
// override PoolTokenWrapper's stake() function
function stake(uint256 pool, uint256 amount)
public
poolExists(pool)
updateReward(msg.sender, pool)
whenNotPaused()
{
Pool memory p = pools[pool];
require(block.timestamp >= p.periodStart, "pool not open");
require(amount.add(balanceOf(msg.sender, pool)) <= p.maxStake, "stake exceeds max");
super.stake(pool, amount);
emit Staked(msg.sender, pool, amount);
}
// override PoolTokenWrapper's withdraw() function
function withdraw(uint256 pool, uint256 amount) public poolExists(pool) updateReward(msg.sender, pool) {
require(amount > 0, "cannot withdraw 0");
super.withdraw(pool, amount);
emit Withdrawn(msg.sender, pool, amount);
}
// override PoolTokenWrapper's transfer() function
function transfer(uint256 fromPool,
uint256 toPool,
uint256 amount)
public
poolExists(fromPool)
poolExists(toPool)
updateReward(msg.sender, fromPool)
updateReward(msg.sender, toPool)
whenNotPaused()
{
Pool memory toP = pools[toPool];
require(block.timestamp >= toP.periodStart, "pool not open");
require(amount.add(balanceOf(msg.sender, toPool)) <= toP.maxStake, "stake exceeds max");
super.transfer(fromPool, toPool, amount);
emit Transferred(msg.sender, fromPool, toPool, amount);
}
function transferAll(uint256 fromPool, uint256 toPool) external {
transfer(fromPool, toPool, balanceOf(msg.sender, fromPool));
}
function exit(uint256 pool) external {
withdraw(pool, balanceOf(msg.sender, pool));
}
function redeem(uint256 pool, uint256 card)
public
payable
poolExists(pool)
cardExists(pool, card)
updateReward(msg.sender, pool)
{
Pool storage p = pools[pool];
Card memory c = p.cards[card];
require(block.timestamp >= c.releaseTime, "card not released");
require(p.points[msg.sender] >= c.points, "not enough pineapples");
require(msg.value == c.mintFee, "support our artists, send eth");
if (c.mintFee > 0) {
uint256 _controllerShare = msg.value.mul(p.controllerShare).div(1000);
uint256 _artistRoyalty = msg.value.sub(_controllerShare);
require(_artistRoyalty.add(_controllerShare) == msg.value, "problem with fee");
p.feesCollected = p.feesCollected.add(c.mintFee);
pendingWithdrawals[controller] = pendingWithdrawals[controller].add(_controllerShare);
pendingWithdrawals[p.artist] = pendingWithdrawals[p.artist].add(_artistRoyalty);
}
p.points[msg.sender] = p.points[msg.sender].sub(c.points);
p.spentPineapples = p.spentPineapples.add(c.points);
memeLtd.mint(msg.sender, card, 1, "");
emit Redeemed(msg.sender, pool, c.points);
}
function rescuePineapples(address account, uint256 pool)
public
poolExists(pool)
updateReward(account, pool)
returns (uint256)
{
require(msg.sender == rescuer, "!rescuer");
Pool storage p = pools[pool];
uint256 earnedPoints = p.points[account];
p.spentPineapples = p.spentPineapples.add(earnedPoints);
p.points[account] = 0;
// transfer remaining MEME to the account
if (balanceOf(account, pool) > 0) {
_rescuePineapples(account, pool);
}
emit Redeemed(account, pool, earnedPoints);
return earnedPoints;
}
function setArtist(uint256 pool, address artist) public onlyOwner {
uint256 amount = pendingWithdrawals[artist];
pendingWithdrawals[artist] = 0;
pendingWithdrawals[artist] = pendingWithdrawals[artist].add(amount);
pools[pool].artist = artist;
emit UpdatedArtist(pool, artist);
}
function setController(address _controller) public onlyOwner {
uint256 amount = pendingWithdrawals[controller];
pendingWithdrawals[controller] = 0;
pendingWithdrawals[_controller] = pendingWithdrawals[_controller].add(amount);
controller = _controller;
}
function setRescuer(address _rescuer) public onlyOwner {
rescuer = _rescuer;
}
function setControllerShare(uint256 pool, uint256 _controllerShare) public onlyOwner poolExists(pool) {
pools[pool].controllerShare = _controllerShare;
}
function addCard(uint256 pool,
uint256 id,
uint256 points,
uint256 mintFee,
uint256 releaseTime) public onlyOwner poolExists(pool) {
Card storage c = pools[pool].cards[id];
c.points = points;
c.releaseTime = releaseTime;
c.mintFee = mintFee;
emit CardAdded(pool, id, points, mintFee, releaseTime);
}
function createCard(uint256 pool,
uint256 supply,
uint256 points,
uint256 mintFee,
uint256 releaseTime) public onlyOwner poolExists(pool) returns (uint256) {
uint256 tokenId = memeLtd.create(supply, 0, "", "");
require(tokenId > 0, "ERC1155 create did not succeed");
Card storage c = pools[pool].cards[tokenId];
c.points = points;
c.releaseTime = releaseTime;
c.mintFee = mintFee;
emit CardAdded(pool, tokenId, points, mintFee, releaseTime);
return tokenId;
}
function createPool(uint256 id,
uint256 periodStart,
uint256 maxStake,
uint256 rewardRate,
uint256 controllerShare,
address artist) public onlyOwner returns (uint256) {
require(pools[id].rewardRate == 0, "pool exists");
Pool storage p = pools[id];
p.periodStart = periodStart;
p.maxStake = maxStake;
p.rewardRate = rewardRate;
p.controllerShare = controllerShare;
p.artist = artist;
emit PoolAdded(id, artist, periodStart, rewardRate, maxStake);
}
function withdrawFee() public {
uint256 amount = pendingWithdrawals[msg.sender];
require(amount > 0, "nothing to withdraw");
pendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(amount);
}
}
| 231,489 | 850 |
95518c0ae2da3ba1a16a3f5dcf1ecb4a452f55f51c8927b90e417440a10b35ce
| 11,503 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x05ea5336c73f3a3fbd8238efb519d6731ce91844.sol
| 2,927 | 9,916 |
pragma solidity ^0.4.16;
library Math {
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 divf(int256 numerator, int256 denominator, uint256 precision) internal pure returns(int256) {
int256 _numerator = numerator * int256(10 ** (precision + 1));
int256 _quotient = ((_numerator / denominator) + 5) / 10;
return _quotient;
}
function percent(uint256 value, uint256 per) internal pure returns(uint256) {
return uint256((divf(int256(value), 100, 4) * int256(per)) / 10000);
}
function random(uint256 nonce, int256 min, int256 max) internal view returns(int256) {
return int256(uint256(keccak256(nonce + block.number + block.timestamp + uint256(block.coinbase))) % uint256((max - min))) + min;
}
}
contract Ownable {
address public owner;
modifier onlyOwner() { require(msg.sender == owner); _; }
function Ownable() public {
owner = msg.sender;
}
function updateContractOwner(address newOwner) external onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract DiceForSlice is Ownable {
// Contract events
event UserBet (address user, uint8 number1, uint8 number2, uint8 number3, uint8 number4, uint8 number5);
event DiceRoll (uint8 number1, uint8 number2, uint8 number3, uint8 number4, uint8 number5);
event Loser (address loser);
event WeHaveAWinner (address winner, uint256 amount);
event OMGItIsJackPot(address winner);
// Address storage for referral system
mapping(address => uint256) private bets;
// Sponsor data
address private sponsor;
uint256 private sponsorDiff = 100000000000000000;
uint256 public sponsorValue = 0;
// Nonce for more random
uint256 private nonce = 1;
// Current balances of contract
// -bank - available reward value
// -stock - available value for restore bank in emergency
uint256 public bank = 0;
uint256 public stock = 0;
// Bet price
uint256 private betPrice = 500000000000000000;
// Current bet split rules (in percent)
uint8 private partBank = 55;
uint8 private partOwner = 20;
uint8 private partSponsor = 12;
uint8 private partStock = 10;
uint8 private partReferral = 3;
// Current rewards (in percent from bank)
uint8 private rewardOne = 10;
uint8 private rewardTwo = 20;
uint8 private rewardThree = 30;
uint8 private rewardFour = 50;
uint8 private jackPot = 100;
// Current number min max
uint8 private minNumber = 1;
uint8 private maxNumber = 6;
modifier isValidBet(uint8 reward) {
require(msg.value == Math.percent(betPrice, reward));
_;
}
modifier bankNotEmpty() {
require(bank >= Math.percent(betPrice, rewardTwo));
require(address(this).balance >= bank);
_;
}
function fillTheBank() external payable {
require(msg.value >= sponsorDiff);
if (msg.value >= sponsorValue + sponsorDiff) {
sponsorValue = msg.value;
sponsor = msg.sender;
}
bank = Math.add(bank, msg.value);
}
function appendStock(uint256 amount) external onlyOwner {
require(amount > 0);
require(stock >= amount);
bank = Math.add(bank, amount);
stock = Math.sub(stock, amount);
}
function getBalance() public view returns(uint256) {
return address(this).balance;
}
function getRN() internal returns(uint8) {
// 7 is max because method sub min from max (7-1 = 6). Look in Math::random implementation
nonce++;
return uint8(Math.random(nonce, minNumber, maxNumber + minNumber));
}
function isValidNumber(uint8 number) internal view returns(bool) {
return number >= minNumber && number <= maxNumber;
}
function splitTheBet(address referral) internal {
uint256 _partBank = Math.percent(msg.value, partBank);
uint256 _partOwner = Math.percent(msg.value, partOwner);
uint256 _partStock = Math.percent(msg.value, partStock);
uint256 _partSponsor = Math.percent(msg.value, partSponsor);
uint256 _partReferral = Math.percent(msg.value, partReferral);
bank = Math.add(bank, _partBank);
stock = Math.add(stock, _partStock);
owner.transfer(_partOwner);
sponsor.transfer(_partSponsor);
if (referral != address(0) && referral != msg.sender && bets[referral] > 0) {
referral.transfer(_partReferral);
} else {
stock = Math.add(stock, _partReferral);
}
}
function isWinner(uint8 required, uint8[5] numbers, uint8[5] randoms) internal pure returns(bool) {
uint8 count = 0;
for (uint8 i = 0; i < numbers.length; i++) {
if (numbers[i] == 0) continue;
for (uint8 j = 0; j < randoms.length; j++) {
if (randoms[j] == 0) continue;
if (randoms[j] == numbers[i]) {
count++;
delete randoms[j];
break;
}
}
}
return count == required;
}
function rewardTheWinner(uint8 reward) internal {
uint256 rewardValue = Math.percent(bank, reward);
require(rewardValue <= getBalance());
require(rewardValue <= bank);
bank = Math.sub(bank, rewardValue);
msg.sender.transfer(rewardValue);
emit WeHaveAWinner(msg.sender, rewardValue);
}
function rollOne(address referral, uint8 number)
external payable isValidBet(rewardOne) bankNotEmpty {
require(isValidNumber(number));
bets[msg.sender]++;
splitTheBet(referral);
uint8[5] memory numbers = [number, 0, 0, 0, 0];
uint8[5] memory randoms = [getRN(), 0, 0, 0, 0];
emit UserBet(msg.sender, number, 0, 0, 0, 0);
emit DiceRoll(randoms[0], 0, 0, 0, 0);
if (isWinner(1, numbers, randoms)) {
rewardTheWinner(rewardOne);
} else {
emit Loser(msg.sender);
}
}
function rollTwo(address referral, uint8 number1, uint8 number2)
external payable isValidBet(rewardTwo) bankNotEmpty {
require(isValidNumber(number1) && isValidNumber(number2));
bets[msg.sender]++;
splitTheBet(referral);
uint8[5] memory numbers = [number1, number2, 0, 0, 0];
uint8[5] memory randoms = [getRN(), getRN(), 0, 0, 0];
emit UserBet(msg.sender, number1, number2, 0, 0, 0);
emit DiceRoll(randoms[0], randoms[1], 0, 0, 0);
if (isWinner(2, numbers, randoms)) {
rewardTheWinner(rewardTwo);
} else {
emit Loser(msg.sender);
}
}
function rollThree(address referral, uint8 number1, uint8 number2, uint8 number3)
external payable isValidBet(rewardThree) bankNotEmpty {
require(isValidNumber(number1) && isValidNumber(number2) && isValidNumber(number3));
bets[msg.sender]++;
splitTheBet(referral);
uint8[5] memory numbers = [number1, number2, number3, 0, 0];
uint8[5] memory randoms = [getRN(), getRN(), getRN(), 0, 0];
emit UserBet(msg.sender, number1, number2, number3, 0, 0);
emit DiceRoll(randoms[0], randoms[1], randoms[2], 0, 0);
if (isWinner(3, numbers, randoms)) {
rewardTheWinner(rewardThree);
} else {
emit Loser(msg.sender);
}
}
function rollFour(address referral, uint8 number1, uint8 number2, uint8 number3, uint8 number4)
external payable isValidBet(rewardFour) bankNotEmpty {
require(isValidNumber(number1) && isValidNumber(number2) && isValidNumber(number3) && isValidNumber(number4));
bets[msg.sender]++;
splitTheBet(referral);
uint8[5] memory numbers = [number1, number2, number3, number4, 0];
uint8[5] memory randoms = [getRN(), getRN(), getRN(), getRN(), 0];
emit UserBet(msg.sender, number1, number2, number3, number4, 0);
emit DiceRoll(randoms[0], randoms[1], randoms[2], randoms[3], 0);
if (isWinner(4, numbers, randoms)) {
rewardTheWinner(rewardFour);
} else {
emit Loser(msg.sender);
}
}
function rollFive(address referral, uint8 number1, uint8 number2, uint8 number3, uint8 number4, uint8 number5)
external payable isValidBet(jackPot) bankNotEmpty {
require(isValidNumber(number1) && isValidNumber(number2) && isValidNumber(number3) && isValidNumber(number4) && isValidNumber(number5));
bets[msg.sender]++;
splitTheBet(referral);
uint8[5] memory numbers = [number1, number2, number3, number4, number5];
uint8[5] memory randoms = [getRN(), getRN(), getRN(), getRN(), getRN()];
emit UserBet(msg.sender, number1, number2, number3, number4, number5);
emit DiceRoll(randoms[0], randoms[1], randoms[2], randoms[3], randoms[4]);
if (isWinner(5, numbers, randoms)) {
rewardTheWinner(jackPot);
emit OMGItIsJackPot(msg.sender);
} else {
emit Loser(msg.sender);
}
}
}
| 214,069 | 851 |
7114da08aa8abf5b88f0bbc7965b464a5acd0ed77f3a582f93ada24958c6e019
| 26,767 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/CourtFarming_RoomLPStake-0xfec868e10c859383a714ca71ff2016e5d4e22664.sol
| 5,025 | 18,311 |
pragma solidity ^0.5.0;
interface ICourtStake{
function lockedStake(uint256 amount, address beneficiar, uint256 StartReleasingTime, uint256 batchCount, uint256 batchPeriod) external;
}
interface IMERC20 {
function mint(address account, uint amount) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract CourtFarming_RoomLPStake {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public constant stakedToken = IERC20(0xBE55c87dFf2a9f5c95cB5C07572C51fd91fe0732);
IMERC20 public constant courtToken = IMERC20(0x0538A9b4f4dcB0CB01A7fA34e17C0AC947c22553);
uint256 private _totalStaked;
mapping(address => uint256) private _balances;
// last updated block number
uint256 private _lastUpdateBlock;
// incentive rewards
uint256 public incvFinishBlock; // finish incentive rewarding block number
uint256 private _incvRewardPerBlock; // incentive reward per block
uint256 private _incvAccRewardPerToken; // accumulative reward per token
mapping(address => uint256) private _incvRewards; // reward balances
mapping(address => uint256) private _incvPrevAccRewardPerToken;// previous accumulative reward per token (for a user)
uint256 public incvStartReleasingTime; // incentive releasing time
uint256 public incvBatchPeriod; // incentive batch period
uint256 public incvBatchCount; // incentive batch count
mapping(address => uint256) public incvWithdrawn;
address public owner;
enum TransferRewardState {
Succeeded,
RewardsStillLocked
}
address public courtStakeAddress;
event Staked(address indexed user, uint256 amount);
event Unstaked(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 reward);
event ClaimIncentiveReward(address indexed user, uint256 reward);
event StakeRewards(address indexed user, uint256 amount, uint256 lockTime);
event CourtStakeChanged(address oldAddress, address newAddress);
event StakeParametersChanged(uint256 incvRewardPerBlock, uint256 incvRewardFinsishBlock, uint256 incvLockTime);
constructor () public {
owner = msg.sender;
uint256 incvRewardsPerBlock = 57870370370370369;
uint256 incvRewardsPeriodInDays = 90;
incvStartReleasingTime = 1620914400; // 13/05/2021 // check https://www.epochconverter.com/ for timestamp
incvBatchPeriod = 1 days;
incvBatchCount = 1;
_stakeParametrsCalculation(incvRewardsPerBlock, incvRewardsPeriodInDays, incvStartReleasingTime);
_lastUpdateBlock = blockNumber();
}
function _stakeParametrsCalculation(uint256 incvRewardsPerBlock, uint256 incvRewardsPeriodInDays, uint256 iLockTime) internal{
uint256 incvRewardBlockCount = incvRewardsPeriodInDays * 5760;
uint256 incvRewardPerBlock = incvRewardsPerBlock;
_incvRewardPerBlock = incvRewardPerBlock * (1e18);
incvFinishBlock = blockNumber().add(incvRewardBlockCount);
incvStartReleasingTime = iLockTime;
}
function changeStakeParameters(uint256 incvRewardsPerBlock, uint256 incvRewardsPeriodInDays, uint256 iLockTime) public {
require(msg.sender == owner, "can be called by owner only");
updateReward(address(0));
_stakeParametrsCalculation(incvRewardsPerBlock, incvRewardsPeriodInDays, iLockTime);
emit StakeParametersChanged(_incvRewardPerBlock, incvFinishBlock, incvStartReleasingTime);
}
function updateReward(address account) public {
// reward algorithm
// in general: rewards = (reward per token ber block) user balances
uint256 cnBlock = blockNumber();
// update accRewardPerToken, in case totalSupply is zero; do not increment accRewardPerToken
if (_totalStaked > 0) {
uint256 incvlastRewardBlock = cnBlock < incvFinishBlock ? cnBlock : incvFinishBlock;
if (incvlastRewardBlock > _lastUpdateBlock) {
_incvAccRewardPerToken = incvlastRewardBlock.sub(_lastUpdateBlock)
.mul(_incvRewardPerBlock).div(_totalStaked)
.add(_incvAccRewardPerToken);
}
}
_lastUpdateBlock = cnBlock;
if (account != address(0)) {
uint256 incAccRewardPerTokenForUser = _incvAccRewardPerToken.sub(_incvPrevAccRewardPerToken[account]);
if (incAccRewardPerTokenForUser > 0) {
_incvRewards[account] =
_balances[account]
.mul(incAccRewardPerTokenForUser)
.div(1e18)
.add(_incvRewards[account]);
_incvPrevAccRewardPerToken[account] = _incvAccRewardPerToken;
}
}
}
function stake(uint256 amount) public {
updateReward(msg.sender);
if (amount > 0) {
_totalStaked = _totalStaked.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakedToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
}
function unstake(uint256 amount, bool claim) public {
updateReward(msg.sender);
if (amount > 0) {
_totalStaked = _totalStaked.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakedToken.safeTransfer(msg.sender, amount);
emit Unstaked(msg.sender, amount);
}
claim = false;
}
function stakeIncvRewards(uint256 amount) public returns (bool) {
updateReward(msg.sender);
uint256 incvReward = _incvRewards[msg.sender];
if (amount > incvReward || courtStakeAddress == address(0)) {
return false;
}
_incvRewards[msg.sender] -= amount; // no need to use safe math sub, since there is check for amount > reward
courtToken.mint(address(this), amount);
ICourtStake courtStake = ICourtStake(courtStakeAddress);
courtStake.lockedStake(amount, msg.sender, incvStartReleasingTime, incvBatchCount, incvBatchPeriod);
emit StakeRewards(msg.sender, amount, incvStartReleasingTime);
}
function setCourtStake(address courtStakeAdd) public {
require(msg.sender == owner, "only contract owner can change");
address oldAddress = courtStakeAddress;
courtStakeAddress = courtStakeAdd;
IERC20 courtTokenERC20 = IERC20(address(courtToken));
courtTokenERC20.approve(courtStakeAdd, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
emit CourtStakeChanged(oldAddress, courtStakeAdd);
}
function rewards(address account) public view returns (uint256 reward, uint256 incvReward) {
// read version of update
uint256 cnBlock = blockNumber();
uint256 incvAccRewardPerToken = _incvAccRewardPerToken;
// update accRewardPerToken, in case totalSupply is zero; do not increment accRewardPerToken
if (_totalStaked > 0) {
uint256 incvLastRewardBlock = cnBlock < incvFinishBlock ? cnBlock : incvFinishBlock;
if (incvLastRewardBlock > _lastUpdateBlock) {
incvAccRewardPerToken = incvLastRewardBlock.sub(_lastUpdateBlock)
.mul(_incvRewardPerBlock).div(_totalStaked)
.add(incvAccRewardPerToken);
}
}
incvReward = _balances[account]
.mul(incvAccRewardPerToken.sub(_incvPrevAccRewardPerToken[account]))
.div(1e18)
.add(_incvRewards[account])
.sub(incvWithdrawn[account]);
reward = 0;
}
function incvRewardInfo() external view returns (uint256 cBlockNumber, uint256 incvRewardPerBlock, uint256 incvRewardFinishBlock, uint256 incvRewardFinishTime, uint256 incvRewardLockTime) {
cBlockNumber = blockNumber();
incvRewardFinishBlock = incvFinishBlock;
incvRewardPerBlock = _incvRewardPerBlock.div(1e18);
if(cBlockNumber < incvFinishBlock){
incvRewardFinishTime = block.timestamp.add(incvFinishBlock.sub(cBlockNumber).mul(15));
}else{
incvRewardFinishTime = block.timestamp.sub(cBlockNumber.sub(incvFinishBlock).mul(15));
}
incvRewardLockTime=incvStartReleasingTime;
}
// expected reward,
// please note this is only expectation, because total balance may changed during the day
function expectedRewardsToday(uint256 amount) external view returns (uint256 reward, uint256 incvReward) {
reward = 0;
uint256 totalIncvRewardPerDay = _incvRewardPerBlock * 5760;
incvReward = totalIncvRewardPerDay.div(_totalStaked.add(amount)).mul(amount).div(1e18);
}
function lastUpdateBlock() external view returns(uint256) {
return _lastUpdateBlock;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function totalStaked() external view returns (uint256) {
return _totalStaked;
}
function blockNumber() public view returns (uint256) {
return block.number;
}
function getCurrentTime() public view returns(uint256){
return block.timestamp;
}
function getVestedAmount(uint256 lockedAmount, uint256 time) internal view returns(uint256){
// if time < StartReleasingTime: then return 0
if(time < incvStartReleasingTime){
return 0;
}
// if locked amount 0 return 0
if (lockedAmount == 0){
return 0;
}
// elapsedBatchCount = ((time - startReleasingTime) / batchPeriod) + 1
uint256 elapsedBatchCount =
time.sub(incvStartReleasingTime)
.div(incvBatchPeriod)
.add(1);
// vestedAmount = lockedAmount * elapsedBatchCount / batchCount
uint256 vestedAmount =
lockedAmount
.mul(elapsedBatchCount)
.div(incvBatchCount);
if(vestedAmount > lockedAmount){
vestedAmount = lockedAmount;
}
return vestedAmount;
}
function incvRewardClaim() public returns(uint256 amount){
updateReward(msg.sender);
amount = getVestedAmount(_incvRewards[msg.sender], getCurrentTime()).sub(incvWithdrawn[msg.sender]);
if(amount > 0){
incvWithdrawn[msg.sender] = incvWithdrawn[msg.sender].add(amount);
courtToken.mint(msg.sender, amount);
emit ClaimIncentiveReward(msg.sender, amount);
}
}
function getBeneficiaryInfo(address ibeneficiary) external view
returns(address beneficiary,
uint256 totalLocked,
uint256 withdrawn,
uint256 releasableAmount,
uint256 nextBatchTime,
uint256 currentTime){
beneficiary = ibeneficiary;
currentTime = getCurrentTime();
totalLocked = _incvRewards[ibeneficiary];
withdrawn = incvWithdrawn[ibeneficiary];
(, uint256 incvReward) = rewards(ibeneficiary);
releasableAmount = getVestedAmount(incvReward, getCurrentTime()).sub(incvWithdrawn[beneficiary]);
nextBatchTime = getIncNextBatchTime(incvReward, ibeneficiary, currentTime);
}
function getIncNextBatchTime(uint256 lockedAmount, address beneficiary, uint256 time) internal view returns(uint256){
// if total vested equal to total locked then return 0
if(getVestedAmount(lockedAmount, time) == _incvRewards[beneficiary]){
return 0;
}
// if time less than startReleasingTime: then return sartReleasingTime
if(time <= incvStartReleasingTime){
return incvStartReleasingTime;
}
// find the next batch time
uint256 elapsedBatchCount =
time.sub(incvStartReleasingTime)
.div(incvBatchPeriod)
.add(1);
uint256 nextBatchTime =
elapsedBatchCount
.mul(incvBatchPeriod)
.add(incvStartReleasingTime);
return nextBatchTime;
}
}
| 196,657 | 852 |
2ee2cf1e6a944e965ad7a745085f5122d82c979cea00ffa73c051a5ec1916fc9
| 35,563 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe42abb395d7666667d6f4e4ac246f773dfe8168a.sol
| 4,926 | 18,222 |
pragma solidity ^0.5.0;
// 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 memory data) public;
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Receiver.sol
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory 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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: 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.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
// File: openzeppelin-solidity/contracts/introspection/ERC165.sol
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
_registerInterface(_INTERFACE_ID_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 _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_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));
_transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
transferFrom(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
require(!_exists(tokenId));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner);
_clearApproval(tokenId);
_ownedTokensCount[owner] = _ownedTokensCount[owner].sub(1);
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
function _burn(uint256 tokenId) internal {
_burn(ownerOf(tokenId), tokenId);
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
require(to != address(0));
_clearApproval(tokenId);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
internal returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
// 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 _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
// register the supported interface to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
}
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 _transferFrom(address from, address to, uint256 tokenId) internal {
super._transferFrom(from, to, tokenId);
_removeTokenFromOwnerEnumeration(from, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
_addTokenToAllTokensEnumeration(tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
_removeTokenFromOwnerEnumeration(owner, tokenId);
// Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
_ownedTokensIndex[tokenId] = 0;
_removeTokenFromAllTokensEnumeration(tokenId);
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
return _ownedTokens[owner];
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[tokenId] = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
// lasTokenId, or just over the end of the array if the token was the last one).
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 tokenIndex = _allTokensIndex[tokenId];
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Metadata.sol
contract 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);
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Metadata.sol
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string memory 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 memory name, string memory symbol) public ERC721Metadata(name, symbol) {
// solhint-disable-previous-line no-empty-blocks
}
}
// File: openzeppelin-solidity/contracts/access/Roles.sol
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];
}
}
// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol
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);
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Mintable.sol
contract ERC721Mintable is ERC721, MinterRole {
function mint(address to, uint256 tokenId) public onlyMinter returns (bool) {
_mint(to, tokenId);
return true;
}
}
// File: contracts/MagazineToken.sol
pragma experimental ABIEncoderV2;
contract MagazineToken is ERC721Full, ERC721Mintable {
event MetadataChanged(uint indexed token, string tokenUri);
mapping (uint => address) minterForToken;
constructor() public ERC721Full("Future Cryptoeconomics", "FUTURE") {}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
minterForToken[tokenId] = msg.sender;
}
function updateMetadata(uint token, string memory tokenUri) public {
require(msg.sender == minterForToken[token]);
_setTokenURI(token, tokenUri);
emit MetadataChanged(token, tokenUri);
}
function mintWithMetadata(address to, uint tokenId, string memory tokenURI) public onlyMinter {
_mint(to, tokenId);
updateMetadata(tokenId, tokenURI);
}
function mintMany(address[] memory to, uint[] memory tokenId, string[] memory tokenURI) public {
for(uint i = 0; i < to.length; i++) {
mintWithMetadata(to[i], tokenId[i], tokenURI[i]);
}
}
}
| 144,479 | 853 |
886dfe2bbe8e2d0f3d86defa0507d2de7bd350300a5ba5802c1e78527c702167
| 23,737 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TStc87A2NUQeT5pk9thvQhKBGAE3dayBo6_TronTrain.sol
| 5,909 | 23,194 |
//SourceUnit: TronTrain.sol
pragma solidity >=0.4.23 <0.6.0;
contract TronTrain {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint16 internal constant LEVEL_PER = 2000;
uint16 internal constant LEVEL_DIVISOR = 10000;
uint public lastUserId = 2;
address public owner;
mapping(uint => uint) public levelPrice;
uint8 public constant levelIncome = 5;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTRONReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event MissedLevelIncome(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level, uint8 networklevel);
event SentDividends(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level, bool isExtra);
event SentLevelincome(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level,uint8 networklevel, bool isExtraLevel);
constructor(address ownerAddress) public {
levelPrice[1] = 400 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
require(users[msg.sender].activeX3Levels[level - 1], "previous level must be activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
require(users[msg.sender].activeX6Levels[level - 1], "previous level must be activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 800 trx, "registration cost 800");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTRONDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTRONDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTRONDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref, users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress, users[userAddress].id, ref, users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref, users[ref].id, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTRONDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTRONDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function getX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTRONReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function findLevelReceiver(address userAddress, address _from, uint8 matrix, uint8 level, uint8 networklevel) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].activeX3Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
isExtraDividends = true;
receiver = users[receiver].referrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].activeX6Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
receiver = users[receiver].referrer;
isExtraDividends = true;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function distributeLevelIncome(address userAddress, uint8 matrix, uint8 level) private {
uint principal = (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR) * 100;
address from_address = userAddress;
bool owner_flag = false;
bool isExtraLevel;
address receiver;
for (uint8 i = 1; i <= 20 ; i++) {
isExtraLevel = false;
if(owner_flag == false)
{
userAddress = users[userAddress].referrer;
if(userAddress == owner)
{
owner_flag = true;
}
}
else
{
userAddress = owner;
}
receiver = userAddress;
if(userAddress != owner)
{
(receiver, isExtraLevel) = findLevelReceiver(receiver, from_address, matrix, level, i);
if(receiver == owner)
{
owner_flag = true;
}
userAddress = receiver;
}
if(!address(uint160(receiver)).send(((principal * levelIncome / LEVEL_DIVISOR))))
{
uint income = (principal * levelIncome / LEVEL_DIVISOR) * 100;
return address(uint160(receiver)).transfer(income);
}
emit SentLevelincome(from_address,users[from_address].id, receiver,users[receiver].id, matrix, level, i ,isExtraLevel);
}
}
function sendTRONDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTRONReceiver(userAddress, _from, matrix, level);
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
if(!address(uint160(receiver)).send(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR))){
return address(uint160(receiver)).transfer(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR));
}
return distributeLevelIncome(_from, matrix, level);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 286,174 | 854 |
85eb89b8e63a677e9ff4b864e1ebfd1e4d938beda648fd1f888781bf4276a2d3
| 14,642 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x362ccd479740ff305a334c5bb0aff0e7b5a87fd5.sol
| 3,868 | 14,304 |
pragma solidity ^0.4.24;
// SafeMath methods
library SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
// Contract must have an owner
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string name_);
function symbol() external view returns (string symbol_);
function decimals() external view returns (uint8 decimals_);
function totalSupply() external view returns (uint256 totalSupply_);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// the main ERC20-compliant multi-timelock enabled contract
contract SOKY is Owned, ERC20Token {
using SafeMath for uint256;
string private constant standard = "20181130150xd";
string private constant version = "1.01afam";
string private name_ = "SOKY";
string private symbol_ = "SOKY";
uint8 private decimals_ = 18;
uint256 private totalSupply_ = uint256(50) * uint256(10)**uint256(8) * uint256(10)**uint256(decimals_);
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
uint256 private later = 0;
uint256 private earlier = 0;
bool private mintable_ = false;
// burn token event
event Burn(address indexed _from, uint256 _value);
// mint token event
event Mint(address indexed _to, uint256 _value);
// timelock-related events
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
// constructor for the ERC20 Token
constructor() public {
balanceP[msg.sender] = totalSupply_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
modifier isMintable() {
require(mintable_);
_;
}
// fast-forward the timelocks for all accounts
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = earlier.add(_earlier);
}
// delay the timelocks for all accounts
function setUnlockLater(uint256 _later) public onlyOwner {
later = later.add(_later);
}
// owner may permanently disable minting
function disableMint() public onlyOwner isMintable {
mintable_ = false;
}
// show if the token is still mintable
function mintable() public view returns (bool) {
return mintable_;
}
// standard ERC20 name function
function name() public view returns (string) {
return name_;
}
// standard ERC20 symbol function
function symbol() public view returns (string) {
return symbol_;
}
// standard ERC20 decimals function
function decimals() public view returns (uint8) {
return decimals_;
}
// standard ERC20 totalSupply function
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
// standard ERC20 allowance function
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowed[_owner][_spender];
}
// show unlocked balance of an account
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) >= lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocked balance of an account
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) < lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// standard ERC20 balanceOf with timelock added
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocks in an account
function showLockTimes(address _address) public view validAddress(_address) returns (uint256[] _times) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = lockTime[_address][i].add(later).sub(earlier);
i++;
}
return tempLockTime;
}
// show values locked in an account's timelocks
function showLockValues(address _address) public view validAddress(_address) returns (uint256[] _values) {
return lockValue[_address];
}
function showLockNum(address _address) public view validAddress(_address) returns (uint256 _lockNum) {
return lockNum[_address];
}
// Calculate and process the timelock states of an account
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (now.add(earlier) >= currentLockTime[i].add(later)) {
balanceP[_address] = balanceP[_address].add(currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
// standard ERC20 transfer
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
// transfer Token with timelocks
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool _success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[msg.sender] >= totalValue && totalValue >= 0);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[msg.sender] = balanceP[msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(msg.sender, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(msg.sender, _to, _value[i]);
i++;
}
return true;
}
// TransferFrom Token with timelocks
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[_from] >= totalValue && totalValue >= 0 && allowed[_from][msg.sender] >= totalValue);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[_from] = balanceP[_from].sub(_value[i]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(_from, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(_from, _to, _value[i]);
i++;
}
return true;
}
// standard ERC20 transferFrom
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool _success) {
if (lockNum[_from] > 0) calcUnlock(_from);
require(balanceP[_from] >= _value && _value >= 0 && allowed[_from][msg.sender] >= _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balanceP[_from] = balanceP[_from].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
// should only be called when first setting an allowed
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// increase or decrease allowed
function increaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= allowed[msg.sender][_spender]) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_value);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
// owner may burn own token
function burn(uint256 _value) public onlyOwner returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
// owner may mint new token and increase total supply
function mint(uint256 _value) public onlyOwner isMintable returns (bool _success) {
balanceP[msg.sender] = balanceP[msg.sender].add(_value);
totalSupply_ = totalSupply_.add(_value);
emit Mint(msg.sender, _value);
return true;
}
// safety methods
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
}
| 198,887 | 855 |
59346edb73058d31ffe2d70cfe92b933dbc9d94bcd772ccb64d6ffb7e0455caa
| 12,117 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x574d60aa41bba8f90e87cfe0581d4e5cd8cd4870_affectedByMiners.sol
| 2,927 | 11,722 |
pragma solidity ^0.5.0;
contract EthexJackpot {
mapping(uint256 => address payable) public tickets;
uint256 public numberEnd;
uint256 public firstNumber;
uint256 public dailyAmount;
uint256 public weeklyAmount;
uint256 public monthlyAmount;
uint256 public seasonalAmount;
bool public dailyProcessed;
bool public weeklyProcessed;
bool public monthlyProcessed;
bool public seasonalProcessed;
address payable private owner;
address public lotoAddress;
address payable public newVersionAddress;
EthexJackpot previousContract;
uint256 public dailyNumberStartPrev;
uint256 public weeklyNumberStartPrev;
uint256 public monthlyNumberStartPrev;
uint256 public seasonalNumberStartPrev;
uint256 public dailyStart;
uint256 public weeklyStart;
uint256 public monthlyStart;
uint256 public seasonalStart;
uint256 public dailyEnd;
uint256 public weeklyEnd;
uint256 public monthlyEnd;
uint256 public seasonalEnd;
uint256 public dailyNumberStart;
uint256 public weeklyNumberStart;
uint256 public monthlyNumberStart;
uint256 public seasonalNumberStart;
uint256 public dailyNumberEndPrev;
uint256 public weeklyNumberEndPrev;
uint256 public monthlyNumberEndPrev;
uint256 public seasonalNumberEndPrev;
event Jackpot (uint256 number,
uint256 count,
uint256 amount,
byte jackpotType);
event Ticket (bytes16 indexed id,
uint256 number);
event SuperPrize (uint256 amount,
address winner);
uint256 constant DAILY = 5000;
uint256 constant WEEKLY = 35000;
uint256 constant MONTHLY = 150000;
uint256 constant SEASONAL = 450000;
uint256 constant PRECISION = 1 ether;
uint256 constant DAILY_PART = 84;
uint256 constant WEEKLY_PART = 12;
uint256 constant MONTHLY_PART = 3;
constructor() public payable {
owner = msg.sender;
}
function() external payable { }
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyOwnerOrNewVersion {
require(msg.sender == owner || msg.sender == newVersionAddress);
_;
}
modifier onlyLoto {
require(msg.sender == lotoAddress, "Loto only");
_;
}
function migrate() external onlyOwnerOrNewVersion {
newVersionAddress.transfer(address(this).balance);
}
function registerTicket(bytes16 id, address payable gamer) external onlyLoto {
uint256 number = numberEnd + 1;
if (block.gaslimit >= dailyEnd) { //injected CONTRACT AFFECTED BY MINERS
setDaily();
dailyNumberStart = number;
}
else
if (block.gaslimit == dailyNumberStartPrev) //injected CONTRACT AFFECTED BY MINERS
dailyNumberStart = number;
if (block.timestamp >= weeklyEnd) { //injected CONTRACT AFFECTED BY MINERS
setWeekly();
weeklyNumberStart = number;
}
else
if (block.number == weeklyNumberStartPrev) //injected CONTRACT AFFECTED BY MINERS
weeklyNumberStart = number;
if (block.timestamp >= monthlyEnd) { //injected CONTRACT AFFECTED BY MINERS
setMonthly();
monthlyNumberStart = number;
}
else
if (block.number == monthlyNumberStartPrev) //injected CONTRACT AFFECTED BY MINERS
monthlyNumberStart = number;
if (block.number >= seasonalEnd) { //injected CONTRACT AFFECTED BY MINERS
setSeasonal();
seasonalNumberStart = number;
}
else
if (block.number == seasonalNumberStartPrev) //injected CONTRACT AFFECTED BY MINERS
seasonalNumberStart = number;
numberEnd = number;
tickets[number] = gamer;
emit Ticket(id, number);
}
function setLoto(address loto) external onlyOwner {
lotoAddress = loto;
}
function setNewVersion(address payable newVersion) external onlyOwner {
newVersionAddress = newVersion;
}
function payIn() external payable {
uint256 distributedAmount = dailyAmount + weeklyAmount + monthlyAmount + seasonalAmount;
if (block.number < address(this).balance) { //injected CONTRACT AFFECTED BY MINERS
uint256 amount = (address(this).balance - distributedAmount) / 4;
dailyAmount += amount;
weeklyAmount += amount;
monthlyAmount += amount;
seasonalAmount += amount;
}
}
function settleJackpot() external {
if (block.timestamp >= dailyEnd) //injected CONTRACT AFFECTED BY MINERS
setDaily();
if (block.gaslimit >= weeklyEnd) //injected CONTRACT AFFECTED BY MINERS
setWeekly();
if (block.timestamp >= monthlyEnd) //injected CONTRACT AFFECTED BY MINERS
setMonthly();
if (block.number >= seasonalEnd) //injected CONTRACT AFFECTED BY MINERS
setSeasonal();
if (block.number == dailyStart || (dailyStart < block.number - 256))
return;
uint48 modulo = uint48(bytes6(blockhash(dailyStart) << 29));
uint256 dailyPayAmount;
uint256 weeklyPayAmount;
uint256 monthlyPayAmount;
uint256 seasonalPayAmount;
uint256 dailyWin;
uint256 weeklyWin;
uint256 monthlyWin;
uint256 seasonalWin;
if (dailyProcessed == false) {
dailyPayAmount = dailyAmount * PRECISION / DAILY_PART / PRECISION;
dailyAmount -= dailyPayAmount;
dailyProcessed = true;
dailyWin = getNumber(dailyNumberStartPrev, dailyNumberEndPrev, modulo);
emit Jackpot(dailyWin, dailyNumberEndPrev - dailyNumberStartPrev + 1, dailyPayAmount, 0x01);
}
if (weeklyProcessed == false) {
weeklyPayAmount = weeklyAmount * PRECISION / WEEKLY_PART / PRECISION;
weeklyAmount -= weeklyPayAmount;
weeklyProcessed = true;
weeklyWin = getNumber(weeklyNumberStartPrev, weeklyNumberEndPrev, modulo);
emit Jackpot(weeklyWin, weeklyNumberEndPrev - weeklyNumberStartPrev + 1, weeklyPayAmount, 0x02);
}
if (monthlyProcessed == false) {
monthlyPayAmount = monthlyAmount * PRECISION / MONTHLY_PART / PRECISION;
monthlyAmount -= monthlyPayAmount;
monthlyProcessed = true;
monthlyWin = getNumber(monthlyNumberStartPrev, monthlyNumberEndPrev, modulo);
emit Jackpot(monthlyWin, monthlyNumberEndPrev - monthlyNumberStartPrev + 1, monthlyPayAmount, 0x04);
}
if (seasonalProcessed == false) {
seasonalPayAmount = seasonalAmount;
seasonalAmount -= seasonalPayAmount;
seasonalProcessed = true;
seasonalWin = getNumber(seasonalNumberStartPrev, seasonalNumberEndPrev, modulo);
emit Jackpot(seasonalWin, seasonalNumberEndPrev - seasonalNumberStartPrev + 1, seasonalPayAmount, 0x08);
}
if (block.number > 0) //injected CONTRACT AFFECTED BY MINERS
tickets[dailyWin].transfer(dailyPayAmount);
if (block.gaslimit > 0) //injected CONTRACT AFFECTED BY MINERS
tickets[weeklyWin].transfer(weeklyPayAmount);
if (block.gaslimit > 0) //injected CONTRACT AFFECTED BY MINERS
tickets[monthlyWin].transfer(monthlyPayAmount);
if (block.gaslimit > 0) //injected CONTRACT AFFECTED BY MINERS
tickets[seasonalWin].transfer(seasonalPayAmount);
}
function settleSuperPrize(address payable winner) external onlyLoto {
uint256 superPrizeAmount = dailyAmount + weeklyAmount + monthlyAmount + seasonalAmount;
emit SuperPrize(superPrizeAmount, winner);
winner.transfer(superPrizeAmount);
}
function loadTickets(address payable[] calldata addresses, uint256[] calldata numbers) external {
for (uint i = 0; i < addresses.length; i++)
tickets[numbers[i]] = addresses[i];
}
function setOldVersion(address payable oldAddress,
uint256 dailyNumberStartPrevIn,
uint256 weeklyNumberStartPrevIn,
uint256 monthlyNumberStartPrevIn,
uint256 seasonalNumberStartPrevIn,
uint256 dailyNumberStartIn,
uint256 weeklyNumberStartIn,
uint256 monthlyNumberStartIn,
uint256 seasonalNumberStartIn,
uint256 dailyNumberEndPrevIn,
uint256 weeklyNumberEndPrevIn,
uint256 monthlyNumberEndPrevIn,
uint256 seasonalNumberEndPrevIn) external onlyOwner {
previousContract = EthexJackpot(oldAddress);
firstNumber = 1;//previousContract.numberEnd;
dailyStart = block.number / DAILY * DAILY;
dailyEnd = dailyStart + DAILY;
dailyProcessed = true;
weeklyStart = block.number / WEEKLY * WEEKLY;
weeklyEnd = weeklyStart + WEEKLY;
weeklyProcessed = true;
monthlyStart = block.number / MONTHLY * MONTHLY;
monthlyEnd = monthlyStart + MONTHLY;
monthlyProcessed = true;
seasonalStart = block.number / SEASONAL * SEASONAL;
seasonalEnd = seasonalStart + SEASONAL;
seasonalProcessed = true;
dailyNumberStartPrev = dailyNumberStartPrevIn;
weeklyNumberStartPrev = weeklyNumberStartPrevIn;
monthlyNumberStartPrev = monthlyNumberStartPrevIn;
seasonalNumberStartPrev = seasonalNumberStartPrevIn;
dailyNumberStart = dailyNumberStartIn;
weeklyNumberStart = weeklyNumberStartIn;
monthlyNumberStart = monthlyNumberStartIn;
seasonalNumberStart = seasonalNumberStartIn;
dailyNumberEndPrev = dailyNumberEndPrevIn;
weeklyNumberEndPrev = weeklyNumberEndPrevIn;
monthlyNumberEndPrev = monthlyNumberEndPrevIn;
seasonalNumberEndPrev = seasonalNumberEndPrevIn;
numberEnd = previousContract.numberEnd();
dailyAmount = previousContract.dailyAmount();
weeklyAmount = previousContract.weeklyAmount();
monthlyAmount = previousContract.monthlyAmount();
seasonalAmount = previousContract.seasonalAmount() + 19599522250000000000;
}
function getAddress(uint256 number) public returns (address payable) {
if (block.timestamp <= firstNumber) //injected CONTRACT AFFECTED BY MINERS
return previousContract.getAddress(number);
return tickets[number];
}
function setDaily() private {
dailyProcessed = dailyNumberEndPrev == numberEnd;
dailyStart = dailyEnd;
dailyEnd = dailyStart + DAILY;
dailyNumberStartPrev = dailyNumberStart;
dailyNumberEndPrev = numberEnd;
}
function setWeekly() private {
weeklyProcessed = weeklyNumberEndPrev == numberEnd;
weeklyStart = weeklyEnd;
weeklyEnd = weeklyStart + WEEKLY;
weeklyNumberStartPrev = weeklyNumberStart;
weeklyNumberEndPrev = numberEnd;
}
function setMonthly() private {
monthlyProcessed = monthlyNumberEndPrev == numberEnd;
monthlyStart = monthlyEnd;
monthlyEnd = monthlyStart + MONTHLY;
monthlyNumberStartPrev = monthlyNumberStart;
monthlyNumberEndPrev = numberEnd;
}
function setSeasonal() private {
seasonalProcessed = seasonalNumberEndPrev == numberEnd;
seasonalStart = seasonalEnd;
seasonalEnd = seasonalStart + SEASONAL;
seasonalNumberStartPrev = seasonalNumberStart;
seasonalNumberEndPrev = numberEnd;
}
function getNumber(uint256 startNumber, uint256 endNumber, uint48 modulo) pure private returns (uint256) {
return startNumber + modulo % (endNumber - startNumber + 1);
}
}
| 280,860 | 856 |
ca52e3814182e4d2520b599cb93655913e05936c6d2078d2b25e7b6f9fd5cf5a
| 15,899 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x545D769eE4f6e840888d1ecdba65743EA35Eb296/contract.sol
| 4,142 | 15,404 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(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);
}
}
}
}
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 MemesFinance is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'MemesFinance';
string private _symbol = 'MEMES';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.mul(3).div(100);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 252,598 | 857 |
1f0650af3389370caab4bfcc6fc0949e66411d783ddef4f5961de88fcd487f4e
| 17,000 |
.sol
|
Solidity
| false |
388150634
|
candlegenie/solidity
|
99c25153b82e4295145234049d0a967dcba26c18
|
CandleGenieEvents.sol
| 3,540 | 14,276 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
//CONTEXT
abstract contract Context
{
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
//OWNABLE
abstract contract Ownable is Context
{
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor()
{
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function OwnershipRenounce() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function OwnershipTransfer(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//CONTRACT
contract CandleGenieLiveEvents is Ownable
{
// STRUTCTURES
enum Position {None, One, Draw, Two}
enum Status {None, Open, Finished, Cancelled}
struct LiveEvent
{
uint256 id;
uint256 startTimestamp;
uint256 closeTimestamp;
uint256 endTimestamp;
string category;
string data;
uint256 oneAmount;
uint256 drawAmount;
uint256 twoAmount;
uint256 rewardAmount;
uint256 rewardBaseAmount;
uint256 betCount;
Position position;
Status status;
}
struct Bet
{
uint256 eventId;
Position position;
uint256 amount;
bool claimed;
}
// MAPPINGS
mapping(uint256 => LiveEvent) public Events;
mapping(uint256 => mapping(address => Bet)) public Bets;
mapping(address => uint256[]) internal UserEnteredEvents;
mapping(address=>bool) internal Blacklist;
// VARIABLES
address public operatorAddress;
uint256 public rewardRate = 97; // Prize reward rate %
uint256 constant internal minimumRewardRate = 90; // Minimum reward rate 90%
uint256 public minAmount;
uint256 public currentID;
uint256[] internal openEvents;
// EVENTS
event LiveEventAdd(uint256 indexed id, uint256 blockNumber, uint256 closeTimeStamp, uint256 endTimestamp, string category, string data);
event LiveEventEdit(uint256 indexed id, uint256 blockNumber, uint256 closeTimeStamp, uint256 endTimestamp, string category, string data);
event LiveEventStart(uint256 indexed id, uint256 blockNumber, uint256 startTimestamp);
event LiveEventCancel(uint256 indexed id, uint256 blockNumber);
event LiveEventEnd(uint256 indexed id, uint256 blockNumber, int position);
event BetEnter(address indexed sender, uint256 indexed id, uint256 amount, int position);
event BetClaim(address indexed sender, uint256 indexed id, uint256 amount);
event RewardsCalculated(uint256 indexed id, uint256 rewardBaseAmount, uint256 rewardAmount);
event SetRewardRate(uint256 rewardRate);
// CONSCTRUCTOR
constructor(address _operatorAddress, uint256 _minAmount)
{
operatorAddress = _operatorAddress;
minAmount = _minAmount;
}
// MODIFIERS
modifier onlyOwnerOrOperator()
{
require(msg.sender == _owner || msg.sender == operatorAddress, "Only owner or operator can call this function");
_;
}
modifier notContract()
{
require(!isContract(msg.sender), "contract not allowed");
require(msg.sender == tx.origin, "proxy contract not allowed");
_;
}
// FUNCTIONS
function isContract(address addr) internal view returns (bool)
{
uint256 size;
assembly {size := extcodesize(addr)}
return size > 0;
}
function setRewardRate(uint256 _rewardRate) external onlyOwner
{
require(_rewardRate >= minimumRewardRate, "Reward rate can't be lower than minimum reward rate");
rewardRate = _rewardRate;
emit SetRewardRate(_rewardRate);
}
function fundsInject() external payable onlyOwner {}
function fundsExtract(uint256 value) external onlyOwner {transferBNB(owner(), value);}
function transferBNB(address to, uint256 value) internal
{
(bool success,) = to.call{gas: 23000, value: value}("");
require(success, "Transfer Failed");
}
function addOpenEvent(uint256 id) internal
{
openEvents.push(id);
}
function removeOpenEvent(uint256 id) internal
{
uint eventOldIndex;
for (uint i = 0; i < openEvents.length; i++)
{
if (openEvents[i] == id)
{
eventOldIndex = i;
}
}
uint eventNewIndex = openEvents.length - 1;
if (eventNewIndex < 0)
{
eventNewIndex = 0;
}
openEvents[eventOldIndex] = openEvents[eventNewIndex];
openEvents.pop();
}
function liveEventAdd(uint256 closeTimeStamp, uint256 endTimestamp, string memory category, string memory data) public onlyOwnerOrOperator
{
require(closeTimeStamp > 0, "Invalid close timestamp");
require(endTimestamp > 0, "Invalid end timestamp");
require(closeTimeStamp < endTimestamp, "Close timestamp must be lower than end timestamp");
require(bytes(category).length > 0, "category can not be empty");
require(bytes(data).length > 0, "Data can not be empty");
LiveEvent storage liveEvent = Events[currentID];
liveEvent.id = currentID;
liveEvent.closeTimestamp = closeTimeStamp;
liveEvent.endTimestamp = endTimestamp;
liveEvent.category = category;
liveEvent.data = data;
liveEvent.position = Position.None;
// Increasing current ID
currentID++;
emit LiveEventAdd(currentID, block.number, closeTimeStamp, endTimestamp, category, data);
}
function liveEventEdit(uint256 id, uint256 closeTimeStamp, uint256 endTimestamp, string memory category, string memory data) public onlyOwner
{
require(closeTimeStamp > 0, "Invalid close timestamp");
require(endTimestamp > 0, "Invalid end timestamp");
require(closeTimeStamp < endTimestamp, "Close timestamp must be lower than close timestamp");
require(bytes(category).length > 0, "category can not be empty");
require(bytes(data).length > 0, "Data can not be empty");
LiveEvent storage liveEvent = Events[id];
liveEvent.closeTimestamp = closeTimeStamp;
liveEvent.endTimestamp = endTimestamp;
liveEvent.category = category;
liveEvent.data = data;
emit LiveEventEdit(id, block.number, closeTimeStamp, endTimestamp, category, data);
}
function liveEventStart(uint256 id) public onlyOwnerOrOperator
{
require(Events[id].closeTimestamp > 0, "Event not defined");
require(Events[id].status != Status.Open, "Event already started");
require(Events[id].status != Status.Cancelled, "Event cancelled");
require(Events[id].status != Status.Finished, "Event finished");
LiveEvent storage liveEvent = Events[id];
liveEvent.startTimestamp = block.timestamp;
liveEvent.status = Status.Open;
// Add Open Event
addOpenEvent(id);
emit LiveEventStart(id, block.number, block.timestamp);
}
function liveEventCancel(uint256 id) public onlyOwnerOrOperator
{
LiveEvent storage liveEvent = Events[id];
liveEvent.status = Status.Cancelled;
if (liveEvent.status == Status.Open)
{
// Remove Open Event
removeOpenEvent(id);
}
emit LiveEventCancel(id, block.number);
}
function liveEventEnd(uint256 id, int position) public onlyOwnerOrOperator
{
require(Events[id].closeTimestamp > 0, "Event not defined");
require(Events[id].status == Status.Open, "Event not started");
require(block.timestamp >= Events[id].endTimestamp, "Live event can only end after end timestamp reached");
LiveEvent storage liveEvent = Events[id];
liveEvent.status = Status.Finished;
if (position == 0)
{
liveEvent.position = Position.One;
}
else if (position == 1)
{
liveEvent.position = Position.Draw;
}
else if (position == 2)
{
liveEvent.position = Position.Two;
}
// Calculating Rewards
calculateRewards(id);
// Remove Open Event
removeOpenEvent(id);
emit LiveEventEnd(id, block.number, position);
}
function calculateRewards(uint256 id) internal
{
require(Events[id].rewardBaseAmount == 0 && Events[id].rewardAmount == 0, "Rewards calculated");
LiveEvent storage liveEvent = Events[id];
uint256 rewardBaseAmount;
uint256 rewardAmount;
uint256 totalAmount = liveEvent.oneAmount + liveEvent.drawAmount + liveEvent.twoAmount;
if (liveEvent.position == Position.One)
{
rewardBaseAmount = liveEvent.oneAmount;
rewardAmount = totalAmount * rewardRate / 100;
}
else if (liveEvent.position == Position.Draw)
{
rewardBaseAmount = liveEvent.drawAmount;
rewardAmount = totalAmount * rewardRate / 100;
}
else if (liveEvent.position == Position.Two)
{
rewardBaseAmount = liveEvent.twoAmount;
rewardAmount = totalAmount * rewardRate / 100;
}
liveEvent.rewardBaseAmount = rewardBaseAmount;
liveEvent.rewardAmount = rewardAmount;
emit RewardsCalculated(id, rewardBaseAmount, rewardAmount);
}
function bettable(uint256 id) public view returns (bool)
{
LiveEvent storage liveEvent = Events[id];
return
liveEvent.status == Status.Open &&
liveEvent.startTimestamp != 0 &&
liveEvent.closeTimestamp != 0 &&
liveEvent.startTimestamp < liveEvent.closeTimestamp;
}
function claimable(uint256 id, address user) public view returns (bool)
{
LiveEvent memory liveEvent = Events[id];
Bet memory bet = Bets[id][user];
return
((liveEvent.position == Position.One && bet.position == Position.One) ||
(liveEvent.position == Position.Draw && bet.position == Position.Draw) ||
(liveEvent.position == Position.Two && bet.position == Position.Two));
}
function betEnter(uint256 id, int position) external payable notContract
{
require(bettable(id), "Event not bettable, not started yet finished or cancelled");
require(msg.value >= minAmount, "Bet amount must be greater than minimum bet amount");
require(Bets[id][msg.sender].amount == 0, "Can only bet once per round");
require(!Blacklist[msg.sender], "Blacklisted! Are you a bot ?");
// Update round data
uint256 amount = msg.value;
LiveEvent storage liveEvent = Events[id];
liveEvent.betCount++;
Bet storage bet = Bets[id][msg.sender];
bet.amount = amount;
bet.eventId = id;
if (position == 0)
{
liveEvent.oneAmount += amount;
bet.position = Position.One;
}
else if (position == 1)
{
liveEvent.drawAmount += amount;
bet.position = Position.Draw;
}
else if (position == 2)
{
liveEvent.twoAmount += amount;
bet.position = Position.Two;
}
UserEnteredEvents[msg.sender].push(id);
emit BetEnter(msg.sender, id, amount, position);
}
function betClaim(uint256 id) external notContract
{
require(Bets[id][msg.sender].amount > 0, "Amount must be greater than zero");
require(!Bets[id][msg.sender].claimed, "Already claimed");
require(!Blacklist[msg.sender], "Blacklisted! Are you a bot ?");
LiveEvent storage liveEvent = Events[id];
Bet storage bet = Bets[id][msg.sender];
uint256 amountToPay;
if (liveEvent.status == Status.Cancelled)
{
amountToPay = bet.amount;
}
else if (liveEvent.status == Status.Finished)
{
require(block.timestamp > Events[id].endTimestamp, "Event has not ended");
require(liveEvent.position != Position.None, "Event has not resulted");
require(claimable(id, msg.sender), "Not eligible for claim");
amountToPay = bet.amount * liveEvent.rewardAmount / liveEvent.rewardBaseAmount;
}
bet.claimed = true;
transferBNB(address(msg.sender), amountToPay);
emit BetClaim(msg.sender, id, amountToPay);
}
function getUserEnteredEventsCount(address user) external view returns (uint256) {
return UserEnteredEvents[user].length;
}
function getUserEnteredEvents(address user, uint256 cursor, uint256 size) external view returns (uint256[] memory, Bet[] memory, uint256)
{
uint256 length = size;
if (length > UserEnteredEvents[user].length - cursor)
{
length = UserEnteredEvents[user].length - cursor;
}
uint256[] memory values = new uint256[](length);
Bet[] memory userBets = new Bet[](length);
for (uint256 i = 0; i < length; i++)
{
values[i] = UserEnteredEvents[user][cursor + i];
userBets[i] = Bets[values[i]][user];
}
return (values, userBets, cursor + length);
}
function getOpenEvents() external view returns (uint256[] memory, uint256)
{
uint256 length = openEvents.length;
uint256[] memory values = new uint256[](length);
for (uint256 i = 0; i < length; i++) {
values[i] = openEvents[ i];
}
return (values, length);
}
}
| 259,867 | 858 |
aa1febfa7cf2174d545a22ca16f6558139245847ba4823293d66d3bb5205018a
| 18,414 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xca4fd347d172e0123c6056dad5f6860b3ea9250a.sol
| 3,590 | 12,916 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract OpportyToken is StandardToken {
string public constant name = "OpportyToken";
string public constant symbol = "OPP";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
function OpportyToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract OpportyYearHold is Pausable {
using SafeMath for uint256;
OpportyToken public token;
uint public holdPeriod;
address public multisig;
// start and end timestamps where investments are allowed
uint public startDate;
uint public endDate;
uint public endSaleDate;
uint private price;
uint public minimalContribution;
// total ETH collected
uint public ethRaised;
enum SaleState { NEW, SALE, ENDED }
SaleState public state;
mapping (uint => address) private assetOwners;
mapping (address => uint) private assetOwnersIndex;
uint public assetOwnersIndexes;
struct Bonus {
uint minAmount;
uint maxAmount;
uint8 bonus;
}
Bonus[] bonuses;
struct Holder {
bool isActive;
uint tokens;
uint holdPeriodTimestamp;
bool withdrawed;
}
mapping(address => Holder) public holderList;
mapping(uint => address) private holderIndexes;
uint private holderIndex;
event TokensTransfered(address contributor , uint amount);
event Hold(address sender, address contributor, uint amount, uint8 holdPeriod);
event ManualChangeStartDate(uint beforeDate, uint afterDate);
event ManualChangeEndDate(uint beforeDate, uint afterDate);
event ChangeMinAmount(uint oldMinAmount, uint minAmount);
event BonusChanged(uint minAmount, uint maxAmount, uint8 newBonus);
event HolderAdded(address addr, uint contribution, uint tokens, uint holdPeriodTimestamp);
event FundsTransferredToMultisig(address multisig, uint value);
event SaleNew();
event SaleStarted();
event SaleEnded();
event ManualPriceChange(uint beforePrice, uint afterPrice);
event HoldChanged(address holder, uint tokens, uint timest);
event TokenChanged(address newAddress);
modifier onlyAssetsOwners() {
require(assetOwnersIndex[msg.sender] > 0 || msg.sender == owner);
_;
}
function OpportyYearHold(address walletAddress, uint start, uint end, uint endSale) public {
holdPeriod = 1 years;
state = SaleState.NEW;
startDate = start;
endDate = end;
endSaleDate = endSale;
price = 0.0002 * 1 ether;
multisig = walletAddress;
minimalContribution = 0.3 * 1 ether;
bonuses.push(Bonus({minAmount: 0, maxAmount: 50, bonus: 35 }));
bonuses.push(Bonus({minAmount: 50, maxAmount: 100, bonus: 40 }));
bonuses.push(Bonus({minAmount: 100, maxAmount: 250, bonus: 45 }));
bonuses.push(Bonus({minAmount: 250, maxAmount: 500, bonus: 50 }));
bonuses.push(Bonus({minAmount: 500, maxAmount: 1000, bonus: 70 }));
bonuses.push(Bonus({minAmount: 1000, maxAmount: 5000, bonus: 80 }));
bonuses.push(Bonus({minAmount: 5000, maxAmount: 99999999, bonus: 90 }));
}
function changeBonus(uint minAmount, uint maxAmount, uint8 newBonus) public {
bool find = false;
for (uint i = 0; i < bonuses.length; ++i) {
if (bonuses[i].minAmount == minAmount && bonuses[i].maxAmount == maxAmount) {
bonuses[i].bonus = newBonus;
find = true;
break;
}
}
if (!find) {
bonuses.push(Bonus({minAmount:minAmount, maxAmount: maxAmount, bonus:newBonus}));
}
BonusChanged(minAmount, maxAmount, newBonus);
}
function getBonus(uint am) public view returns(uint8) {
uint8 bon = 0;
am /= 10 ** 18;
for (uint i = 0; i < bonuses.length; ++i) {
if (am >= bonuses[i].minAmount && am<bonuses[i].maxAmount)
bon = bonuses[i].bonus;
}
return bon;
}
function() public payable {
require(state == SaleState.SALE);
require(msg.value >= minimalContribution);
require(now >= startDate);
if (now > endDate) {
state = SaleState.ENDED;
msg.sender.transfer(msg.value);
SaleEnded();
return ;
}
uint tokenAmount = msg.value.div(price);
tokenAmount += tokenAmount.mul(getBonus(msg.value)).div(100);
tokenAmount *= 10 ** 18;
uint holdTimestamp = endSaleDate.add(holdPeriod);
addHolder(msg.sender, tokenAmount, holdTimestamp);
HolderAdded(msg.sender, msg.value, tokenAmount, holdTimestamp);
forwardFunds();
}
function addHolder(address holder, uint tokens, uint timest) internal {
if (holderList[holder].isActive == false) {
holderList[holder].isActive = true;
holderList[holder].tokens = tokens;
holderList[holder].holdPeriodTimestamp = timest;
holderIndexes[holderIndex] = holder;
holderIndex++;
} else {
holderList[holder].tokens += tokens;
holderList[holder].holdPeriodTimestamp = timest;
}
}
function changeHold(address holder, uint tokens, uint timest) onlyAssetsOwners public {
if (holderList[holder].isActive == true) {
holderList[holder].tokens = tokens;
holderList[holder].holdPeriodTimestamp = timest;
HoldChanged(holder, tokens, timest);
}
}
function forwardFunds() internal {
ethRaised += msg.value;
multisig.transfer(msg.value);
FundsTransferredToMultisig(multisig, msg.value);
}
function newPresale() public onlyOwner {
state = SaleState.NEW;
SaleNew();
}
function startPresale() public onlyOwner {
state = SaleState.SALE;
SaleStarted();
}
function endPresale() public onlyOwner {
state = SaleState.ENDED;
SaleEnded();
}
function addAssetsOwner(address _owner) public onlyOwner {
assetOwnersIndexes++;
assetOwners[assetOwnersIndexes] = _owner;
assetOwnersIndex[_owner] = assetOwnersIndexes;
}
function removeAssetsOwner(address _owner) public onlyOwner {
uint index = assetOwnersIndex[_owner];
delete assetOwnersIndex[_owner];
delete assetOwners[index];
assetOwnersIndexes--;
}
function getAssetsOwners(uint _index) onlyOwner public constant returns (address) {
return assetOwners[_index];
}
function getBalance() public constant returns (uint) {
return token.balanceOf(this);
}
function returnTokens(uint nTokens) public onlyOwner returns (bool) {
require(nTokens <= getBalance());
token.transfer(msg.sender, nTokens);
TokensTransfered(msg.sender, nTokens);
return true;
}
function unlockTokens() public returns (bool) {
require(holderList[msg.sender].isActive);
require(!holderList[msg.sender].withdrawed);
require(now >= holderList[msg.sender].holdPeriodTimestamp);
token.transfer(msg.sender, holderList[msg.sender].tokens);
holderList[msg.sender].withdrawed = true;
TokensTransfered(msg.sender, holderList[msg.sender].tokens);
return true;
}
function setStartDate(uint date) public onlyOwner {
uint oldStartDate = startDate;
startDate = date;
ManualChangeStartDate(oldStartDate, date);
}
function setEndSaleDate(uint date) public onlyOwner {
uint oldEndDate = endSaleDate;
endSaleDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function setEndDate(uint date) public onlyOwner {
uint oldEndDate = endDate;
endDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function setPrice(uint newPrice) public onlyOwner {
uint oldPrice = price;
price = newPrice;
ManualPriceChange(oldPrice, newPrice);
}
function setMinimalContribution(uint minimumAmount) public onlyOwner {
uint oldMinAmount = minimalContribution;
minimalContribution = minimumAmount;
ChangeMinAmount(oldMinAmount, minimalContribution);
}
function batchChangeHoldPeriod(uint holdedPeriod) public onlyAssetsOwners {
for (uint i = 0; i < holderIndex; ++i) {
holderList[holderIndexes[i]].holdPeriodTimestamp = holdedPeriod;
HoldChanged(holderIndexes[i], holderList[holderIndexes[i]].tokens, holdedPeriod);
}
}
function setToken(address newToken) public onlyOwner {
token = OpportyToken(newToken);
TokenChanged(token);
}
function getTokenAmount() public view returns (uint) {
uint tokens = 0;
for (uint i = 0; i < holderIndex; ++i) {
if (!holderList[holderIndexes[i]].withdrawed) {
tokens += holderList[holderIndexes[i]].tokens;
}
}
return tokens;
}
function getEthRaised() constant external returns (uint) {
return ethRaised;
}
}
| 140,431 | 859 |
0e1a875631bd6091c0496c66a6b54b8a5ffee53bc05f7ae722bea626ac816ee6
| 18,083 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/4c/4CBF1A80354750574f8c03dC65a5de2cD3fe998D_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
});
}
}
| 94,707 | 860 |
ac5218923a558717911d7a6e119f5658b502635042f843077f69450f6e86ef2f
| 19,780 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc28e860c9132d55a184f9af53fc85e90aa3a0153.sol
| 4,136 | 15,612 |
pragma solidity ^0.4.20;
contract POTJ {
/// @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 Trevon James";
string public symbol = "PoTJ";
uint8 constant public decimals = 18;
/// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 20;
/// @dev 10% dividends for token transfer
uint8 constant internal transferFee_ = 10;
/// @dev 25% dividends for token selling
uint8 constant internal exitFee_ = 25;
/// @dev 35% of entryFee_ (i.e. 7% dividends) is given to referrer
uint8 constant internal refferalFee_ = 35;
uint256 constant internal tokenPriceInitial_ = 0.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;
}
}
| 208,983 | 861 |
c8832e5a3b1f1229fe99126068d76fd1ba530c84bd26372e337b9ed92790bcde
| 21,618 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/05/059ceee7363634fd827d4102dbd3c118af872d95_SUPERTIGER.sol
| 2,862 | 10,956 |
// 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 SUPERTIGER 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 = 'SUPER TIGER';
string private _symbol = 'SUPERTIGER';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 85,055 | 862 |
a9ad7e481817557cb1d463c83b06f6e47e6636aa551e14f416bf9b24bd681efb
| 27,170 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/95/956d3d65a1b2dace3e4c5e6aa3b4e604601bc2f2_OlympusStaking.sol
| 4,141 | 16,496 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsRUG {
function rebase(uint256 rugProfit_, 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 OlympusStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable RUG;
address public immutable sRUG;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _RUG,
address _sRUG,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_RUG != address(0));
RUG = _RUG;
require(_sRUG != address(0));
sRUG = _sRUG;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(RUG).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(IsRUG(sRUG).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sRUG).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, IsRUG(sRUG).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsRUG(sRUG).balanceForGons(info.gons));
IERC20(RUG).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(sRUG).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(RUG).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsRUG(sRUG).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsRUG(sRUG).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsRUG(sRUG).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(RUG).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sRUG).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sRUG).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;
}
}
| 86,429 | 863 |
88038a87387c2bc17a79c920344b1279ee0d229ac6def0a337bc7701978a030e
| 29,562 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x1e2bA3e4f9cFEeBe5a03Ca20932456009631Bbbc/contract.sol
| 5,096 | 18,221 |
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 DYRToken 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 = 'DYOR';
string private constant _symbol = 'DYR';
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;
}
}
| 253,011 | 864 |
fa3d879c07669e8fee944818ea1e7981fc288e9593df4c2faf2315de058c31e4
| 25,967 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/15/1585b2287d5AAb4f87F4a0afd00F61795aa2010c_SabStaking.sol
| 4,386 | 17,586 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ISSab is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute(uint _staked) external returns (bool);
}
contract SabStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for ISSab;
IERC20 public immutable Sab;
ISSab public immutable SSab;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _Sab,
address _SSab,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Sab != address(0));
Sab = IERC20(_Sab);
require(_SSab != address(0));
SSab = ISSab(_SSab);
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();
Sab.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(SSab.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
SSab.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim (address _recipient) external {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 amount = SSab.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = SSab.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Sab.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
SSab.safeTransferFrom(msg.sender, address(this), _amount);
Sab.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return SSab.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
SSab.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
uint staked = SSab.circulatingSupply();
if (address(distributor) != address(0)) {
distributor.distribute(staked); //sab mint should be updated
}
uint balance = contractBalance();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Sab.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP }
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 102,945 | 865 |
ccc69e6261746348a728335d48e0a7e1a4eb3da1a29b5a32b32659bd91cad488
| 38,044 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xAb283a0E3c1BFBD7eceeACecE51b426364C92595/contract.sol
| 4,875 | 19,129 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// StakedEther Token with Governance.
contract StakedEtherToken is BEP20('StakedEther Token', 'SdEth') {
/// @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
/// @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)
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), "SDETH::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "SDETH::delegateBySig: invalid nonce");
require(now <= expiry, "SDETH::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, "SDETH::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 SDETHs (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, "SDETH::_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;
}
}
| 256,549 | 866 |
86873eef5683471b48ccd21670ab8629211943d42a6e5dab3d6b90644df2f535
| 24,708 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDypG5aBN1CYCb3fpF48gwavJDT7FCr15a_TronFoundation.sol
| 6,104 | 24,189 |
//SourceUnit: TronFound.sol
pragma solidity >=0.4.23 <0.6.0;
contract TronFoundation {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint16 internal constant LEVEL_PER = 2000;
uint16 internal constant LEVEL_DIVISOR = 10000;
uint public lastUserId = 2;
address public owner;
address public deployer;
mapping(uint => uint) public levelPrice;
uint8 public constant levelIncome = 10;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTRONReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event MissedLevelIncome(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level, uint8 networklevel);
event SentDividends(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level, bool isExtra);
event SentLevelincome(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level,uint8 networklevel, bool isExtraLevel);
constructor(address ownerAddress) public {
levelPrice[1] = 400 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
deployer = msg.sender;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function registrationDeployer(address user, address referrerAddress) external payable {
require(msg.sender == deployer, 'Invalid Deployer');
registration(user, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
buyNewLevelInternal(msg.sender, matrix, level);
}
function buyNewLevelDeployer(address user, uint8 matrix, uint8 level) external payable {
require(msg.sender == deployer, 'Invalid Deployer');
buyNewLevelInternal(user, matrix, level);
}
function buyNewLevelInternal(address user, uint8 matrix, uint8 level) private {
require(isUserExists(user), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
if(!(msg.sender==deployer)) require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[user].activeX3Levels[level], "level already activated");
require(users[user].activeX3Levels[level - 1], "previous level must be activated");
if (users[user].x3Matrix[level-1].blocked) {
users[user].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(user, level);
users[user].x3Matrix[level].currentReferrer = freeX3Referrer;
users[user].activeX3Levels[level] = true;
updateX3Referrer(user, freeX3Referrer, level);
distributeLevelIncome(user, matrix, level);
emit Upgrade(user, freeX3Referrer, 1, level);
} else {
require(!users[user].activeX6Levels[level], "level already activated");
require(users[user].activeX6Levels[level - 1], "previous level must be activated");
if (users[user].x6Matrix[level-1].blocked) {
users[user].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(user, level);
users[user].activeX6Levels[level] = true;
updateX6Referrer(user, freeX6Referrer, level);
distributeLevelIncome(user, matrix, level);
emit Upgrade(user, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
if(!(msg.sender==deployer)) require(msg.value == 800 trx, "registration cost 800");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
distributeLevelIncome(userAddress, 1, 1);
distributeLevelIncome(userAddress, 2, 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTRONDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTRONDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTRONDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref, users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress, users[userAddress].id, ref, users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref, users[ref].id, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTRONDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTRONDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function getX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTRONReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function findLevelReceiver(address userAddress, address _from, uint8 matrix, uint8 level, uint8 networklevel) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].activeX3Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
isExtraDividends = true;
receiver = users[receiver].referrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].activeX6Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
receiver = users[receiver].referrer;
isExtraDividends = true;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function distributeLevelIncome(address userAddress, uint8 matrix, uint8 level) private {
if(msg.sender!=deployer)
{
uint principal = (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR) * 100;
address from_address = userAddress;
bool owner_flag = false;
bool isExtraLevel;
address receiver;
for (uint8 i = 1; i <= 10 ; i++) {
isExtraLevel = false;
if(owner_flag == false)
{
userAddress = users[userAddress].referrer;
if(userAddress == owner)
{
owner_flag = true;
}
}
else
{
userAddress = owner;
}
receiver = userAddress;
if(userAddress != owner)
{
(receiver, isExtraLevel) = findLevelReceiver(receiver, from_address, matrix, level, i);
if(receiver == owner)
{
owner_flag = true;
}
userAddress = receiver;
}
if(!address(uint160(receiver)).send(((principal * levelIncome / LEVEL_DIVISOR))))
{
uint income = (principal * levelIncome / LEVEL_DIVISOR) * 100;
return address(uint160(receiver)).transfer(income);
}
emit SentLevelincome(from_address,users[from_address].id, receiver,users[receiver].id, matrix, level, i ,isExtraLevel);
}
}
}
function sendTRONDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
if(msg.sender != deployer)
{
(address receiver, bool isExtraDividends) = findTRONReceiver(userAddress, _from, matrix, level);
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
if(!address(uint160(receiver)).send(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR))){
return address(uint160(receiver)).transfer(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR));
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 296,967 | 867 |
67cfc09545f87267f0afb047e73fdabdef79d2cc10654a778c41335edea8dab5
| 17,696 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e8/e8ae4eea5a66f1f98f727d65cb7935e5b23dc283_ArbNemoAI.sol
| 4,201 | 17,072 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
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;
_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 {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
interface IERC20Permit {
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target, bool success, bytes memory returndata, string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
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);
}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
contract ArbNemoAI is ERC20, ERC20Burnable, Ownable {
using SafeERC20 for IERC20;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isBlackList;
string private _name = 'ArbNemoAI';
string private _symbol = 'AINEMO';
uint256 private _totalSupply = 1000000000000000 * 1e6;
uint256 public feeDenominator = 10000;
uint256 private burnFee = 300;
uint256 private devFee = 100;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
constructor() ERC20(_name, _symbol) {
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
_mint(_msgSender(), _totalSupply);
}
function decimals() public view virtual override returns (uint8) {
return 6;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply - balanceOf(DEAD);
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
return _tokenTransfer(_msgSender(), to, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(sender, spender, amount);
return _tokenTransfer(sender, recipient, amount);
}
function _tokenTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
require(!isBlackList[sender], "Sender blacklisted by Owner");
bool shouldTakeFee = !isFeeExempt[sender] && !isFeeExempt[recipient];
uint256 amountReceived = shouldTakeFee ? takeFee(sender, amount) : amount;
_transfer(sender, recipient, amountReceived);
return true;
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
uint256 devFeeAmount = (amount * devFee) / feeDenominator;
uint256 burnFeeAmount = (amount * burnFee) / feeDenominator;
_transfer(sender, address(this), devFeeAmount);
_transfer(sender, DEAD, burnFeeAmount);
return amount - devFeeAmount - burnFeeAmount;
}
function setIsBlackList(address holder, bool banned) external onlyOwner {
isBlackList[holder] = banned;
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
}
function rescueToken(address tokenAddress) external onlyOwner {
IERC20(tokenAddress).safeTransfer(msg.sender, IERC20(tokenAddress).balanceOf(address(this)));
}
function clearStuckEthBalance() external onlyOwner {
uint256 amountETH = address(this).balance;
(bool success,) = payable(_msgSender()).call{value: amountETH}(new bytes(0));
require(success, "ETH_TRANSFER_FAILED");
}
receive() external payable {}
}
| 47,357 | 868 |
2ebce0136f10babb6b32ffe0f00c31ba05b02f83bc867a07a04a1e472b9c7c5e
| 22,748 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x187c4b0e3819017a5cf07af81a4e2b16166aabc6.sol
| 3,390 | 12,927 |
pragma solidity ^0.5.6;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function 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;
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _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]);
}
}
// File: openzeppelin-solidity/contracts/access/Roles.sol
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];
}
}
// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol
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);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Mintable.sol
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Capped.sol
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);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
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;
}
}
// File: eth-token-recover/contracts/TokenRecover.sol
contract TokenRecover is Ownable {
function recoverERC20(address tokenAddress, uint256 tokenAmount) public onlyOwner {
IERC20(tokenAddress).transfer(owner(), tokenAmount);
}
}
// File: ico-maker/contracts/access/roles/OperatorRole.sol
contract OperatorRole {
using Roles for Roles.Role;
event OperatorAdded(address indexed account);
event OperatorRemoved(address indexed account);
Roles.Role private _operators;
constructor() internal {
_addOperator(msg.sender);
}
modifier onlyOperator() {
require(isOperator(msg.sender));
_;
}
function isOperator(address account) public view returns (bool) {
return _operators.has(account);
}
function addOperator(address account) public onlyOperator {
_addOperator(account);
}
function renounceOperator() public {
_removeOperator(msg.sender);
}
function _addOperator(address account) internal {
_operators.add(account);
emit OperatorAdded(account);
}
function _removeOperator(address account) internal {
_operators.remove(account);
emit OperatorRemoved(account);
}
}
// File: ico-maker/contracts/token/ERC20/BaseERC20Token.sol
contract BaseERC20Token is ERC20Detailed, ERC20Capped, ERC20Burnable, OperatorRole, TokenRecover {
event MintFinished();
event TransferEnabled();
// indicates if minting is finished
bool private _mintingFinished = false;
// indicates if transfer is enabled
bool private _transferEnabled = false;
modifier canMint() {
require(!_mintingFinished);
_;
}
modifier canTransfer(address from) {
require(_transferEnabled || isOperator(from));
_;
}
constructor(string memory name,
string memory symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply)
public
ERC20Detailed(name, symbol, decimals)
ERC20Capped(cap)
{
if (initialSupply > 0) {
_mint(owner(), initialSupply);
}
}
function mintingFinished() public view returns (bool) {
return _mintingFinished;
}
function transferEnabled() public view returns (bool) {
return _transferEnabled;
}
function mint(address to, uint256 value) public canMint returns (bool) {
return super.mint(to, value);
}
function transfer(address to, uint256 value) public canTransfer(msg.sender) returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public canTransfer(from) returns (bool) {
return super.transferFrom(from, to, value);
}
function finishMinting() public onlyOwner canMint {
_mintingFinished = true;
_transferEnabled = true;
emit MintFinished();
emit TransferEnabled();
}
function enableTransfer() public onlyOwner {
_transferEnabled = true;
emit TransferEnabled();
}
function removeOperator(address account) public onlyOwner {
_removeOperator(account);
}
function removeMinter(address account) public onlyOwner {
_removeMinter(account);
}
}
// File: contracts/ERC20Token.sol
contract ERC20Token is BaseERC20Token {
string public builtOn = "https://vittominacori.github.io/erc20-generator";
constructor(string memory name,
string memory symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply)
public
BaseERC20Token(name, symbol, decimals, cap, initialSupply)
{} // solhint-disable-line no-empty-blocks
}
| 213,583 | 869 |
8a4470100cf0ceea55aa9ba55b1fb3865237cb1ed9e42bdb1f6f11b268ba5167
| 28,171 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x521e7c116B265FaA315626b6A2C9073270A83eD3/lthl.sol
| 5,153 | 18,438 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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 LETHAL 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 = 5 * 10**10 * 10**12;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Lethal';
string private _symbol = 'LTHL';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint256 private _maxTxAmount = 25e18;
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 != 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), "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 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() private view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 1 && taxFee <= 10, 'taxFee should be in 1 - 15');
_taxFee = taxFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 9000e18 , 'maxTxAmount should be greater than 9000e18');
_maxTxAmount = maxTxAmount;
}
}
| 254,242 | 870 |
340e2a0193efbb484f6ab817f047357ef00bb729421f16c19eb1fcbca17bfba6
| 13,524 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b1/b17ef6b99c98f68dfe4115cbbb6d72b0f7a1a9ad_CherryForest2.sol
| 3,270 | 11,858 |
// CherryForest2.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// From OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
// simplified (not is Context)
abstract contract Ownable {
// ==== Events ====
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
// ==== Storage ====
// Private so it cannot be changed by inherited contracts
address private _owner;
// ==== Constructor ====
constructor() {
_transferOwnership(msg.sender);
}
// ==== Modifiers ====
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
// ==== Views ====
function owner() public view virtual returns (address) {
return _owner;
}
// ==== Mutators ====
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_);
}
// ==== Internals ====
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 allowance(address owner, address spender) external view returns (uint256);
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);
}
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 CherryForest2 is Ownable {
// ==== Events ====
event Staked (address indexed user, uint80 amount);
event Withdrawn (address indexed user, uint80 amount);
event RewardPaid (address indexed user, uint80 reward);
event RewardAdded (address indexed user, uint80 reward);
event ReserveAdded(address indexed user, uint80 amount);
// ==== Structs ====
// only 1 slot
struct StakerSeat {
uint32 lastSnapshotIndex;
uint32 epochTimerStart;
uint80 balance; // max value: 1 208 925 tokens
// please don't stake more than 1 208 925 spLP tokens
// stake() will revert because of overflow if you do anyway
uint112 rewardEarned;
}
// only 1 slot
struct Snapshot {
uint32 epoch; // epoch of the snapshot
uint112 rewardDistributed; // amount distributed during that Epoch
uint112 rewardPerLPtoken; // accumulated reward per spLP up to that snapshot
}
// ==== Constants ====
uint32 public constant PERIOD = 6 hours;
uint32 public constant withdrawLockupEpochs = 6; // 6 epochs before can withdraw
uint32 public constant rewardLockupEpochs = 3; // 3 epochs before can claimReward
address public constant pool = 0x4e904138B50f8a3Ad71B5303C02F53d0ad359D6C;
address public constant tree = 0x8Dc673878d325C028D08d73C24cD59E15df62a4c;
// ==== Storage ====
// ---- 1 slot ----
uint32 public epoch; // last update epoch
uint112 public totalSupply; // total spLP staked
uint80 public reserve; // total CHRT left to distribute
// this is < this balance of tree because
// some stakers won't have withdrawn their rewards
mapping(address => StakerSeat) public stakers;
Snapshot[] public history;
// ==== Constructor ====
// constructor(address pool_, address tree_) {
constructor() {
// require(pool_ != address(0), "pool cannot be 0x00");
// deploy checks to make sure I'm not an idiot
// check pool symbol is spLP
require(keccak256(abi.encodePacked(IERC20Metadata(pool).symbol())) == keccak256(abi.encodePacked('spLP')),
"pool_ is not a SpookySwap liquidity pool");
// check tree symbol is CHRT
require(keccak256(abi.encodePacked(IERC20Metadata(tree).symbol())) == keccak256(abi.encodePacked('CHRT')),
"tree_ is not the Cherry Tree token contract");
// set immutables in constructor
// pool = pool_;
// tree = tree_;
// create initial snapshop
Snapshot memory initialSnapshot = Snapshot({
epoch : uint32(getEpoch()),
rewardDistributed : 0,
rewardPerLPtoken : 0
});
history.push(initialSnapshot);
// set first epoch
epoch = uint32(getEpoch());
// Important: stake at least one spLP before first reward
// or the application will not start
}
// ==== Pseudo - ERC20 ====
function balanceOf(address account_) public view returns (uint256) {
return stakers[account_].balance;
}
// Pseudo ERC20Metadata so people can watch their st-spLP-CHRY-FTM tokens in MetaMask
// from their MetaMask wallet: they just need to add the Forest contract address as a token in MM
// Other functions of the ERC20 standard are not implemented
function symbol() external pure returns (string memory) { return "stSpLP-T"; }
function name() external pure returns (string memory) { return "CHRT-FTM spLP staked at the Forest"; }
function decimals() external pure returns (uint8) { return 18; }
// ==== Modifiers ====
// ==== Governance ====
// Less Governance == more Trust
// ==== Views ====
// Current epoch
function getEpoch() public view returns (uint256) {
return block.timestamp / PERIOD;
}
// === Read snapshots ===
function getLatestSnapshotIndex() public view returns (uint256) {
return history.length - 1;
}
function getLatestSnapshot() public view returns (Snapshot memory) {
return history[history.length - 1];
}
function getLastSnapshotIndexOf(address staker_) public view returns (uint256) {
return stakers[staker_].lastSnapshotIndex;
}
function getLastSnapshotOf(address staker_) public view returns (Snapshot memory) {
return history[stakers[staker_].lastSnapshotIndex];
}
function canWithdraw(address staker_) external view returns (bool) {
return stakers[staker_].epochTimerStart + withdrawLockupEpochs <= getEpoch();
}
function canClaimReward(address staker_) external view returns (bool) {
return stakers[staker_].epochTimerStart + rewardLockupEpochs <= getEpoch();
}
function rewardPerLPtoken() public view returns (uint256) {
return history[history.length - 1].rewardPerLPtoken;
}
function earned(address staker_) public view returns (uint256) {
StakerSeat memory staker = stakers[staker_];
uint256 latestRPT = history[history.length - 1].rewardPerLPtoken;
uint256 storedRPT = history[staker.lastSnapshotIndex ].rewardPerLPtoken;
return (uint(staker.balance) * (latestRPT - storedRPT) / 1e18) + staker.rewardEarned;
}
// ==== Mutators ====
function stake(uint256 amount_) public returns(bool) {
uint newEpoch = getEpoch();
// check Forest is not lagging in time
if (newEpoch > epoch) {
// Forest is lagging
update();
// After that, Forest will be updated for the whole epoch
}
StakerSeat memory staker = stakers[msg.sender];
staker = _updateStaker(staker);
IERC20(pool).transferFrom(msg.sender, address(this), amount_);
totalSupply += uint80(amount_);
staker.balance += uint80(amount_);
staker.epochTimerStart = uint32(newEpoch); // reset timer
stakers[msg.sender] = staker; // only one swrite !!!!
emit Staked(msg.sender, uint80(amount_));
return true;
}
// withdraw automatically claims
function withdraw(uint256 amount_) public returns(bool) {
uint newEpoch = getEpoch();
// check Forest is not lagging in time
if (newEpoch > epoch) {
update();
}
StakerSeat memory staker = stakers[msg.sender];
staker = _updateStaker(staker);
require(staker.epochTimerStart + withdrawLockupEpochs <= newEpoch,
"Forest: you're still in withdraw lockup");
staker = _claim(staker, newEpoch);
require(staker.balance >= amount_, "Forest: you asked for too much");
totalSupply -= uint80(amount_); // swrite 5 000 gas
require(totalSupply > 1e18, "Forest: at least one spLP must remain");
staker.balance -= uint80(amount_);
stakers[msg.sender] = staker; // only one swrite for staker
IERC20(pool).transfer(msg.sender, amount_);
emit Withdrawn(msg.sender, uint80(amount_));
return true;
}
function exit() external {
// withdraw automatically claims
withdraw(balanceOf(msg.sender));
}
function claimReward() public returns(bool) {
uint newEpoch = getEpoch();
// check Forest is not lagging in time
if (newEpoch > epoch) {
update();
}
StakerSeat memory staker = stakers[msg.sender];
staker = _updateStaker(staker);
staker = _claim(staker, newEpoch);
stakers[msg.sender] = staker; // only one swrite for staker
return true;
}
// add reserve to be distributed
// anyone can add reserve if they want to give CHRT
// to spLP CHRY-FTM stakers
function addReserve(uint amount_) public returns(bool) {
IERC20(tree).transferFrom(msg.sender, address(this), amount_);
reserve += uint80(amount_);
emit ReserveAdded(msg.sender, uint80(amount_));
return true;
}
function update() public returns (bool) {
uint newEpoch = getEpoch();
if (newEpoch <= epoch) {
return false;
}
// below code will only run once per epoch
epoch = uint32(newEpoch);
// Forest is empty
if (reserve < 1e18) {
return false;
}
// no stake
if (totalSupply < 1e18) {
return false;
}
// compute reward
uint reward = ((reserve / 1e21) + 1) * 1e18;
// distribute reward
// new snapshot is a copy of the previous one:
Snapshot memory newSnapshot = getLatestSnapshot();
newSnapshot.epoch = uint32(newEpoch);
newSnapshot.rewardDistributed = uint112(reward);
newSnapshot.rewardPerLPtoken += uint112(reward * 1e18 / totalSupply);
history.push(newSnapshot);
reserve -= uint80(reward);
emit RewardAdded(msg.sender, uint80(reward));
return true;
}
// ==== Privates ====
function _updateStaker(StakerSeat memory staker_) private view returns (StakerSeat memory) {
uint latestSnapshotIdx = history.length - 1;
// update staker if he lags
if (staker_.lastSnapshotIndex < latestSnapshotIdx) {
Snapshot memory latestSnapshot = history[latestSnapshotIdx];
Snapshot memory stakerSnapshot = history[staker_.lastSnapshotIndex];
unchecked {
staker_.rewardEarned += uint112((uint(staker_.balance) * (latestSnapshot.rewardPerLPtoken - stakerSnapshot.rewardPerLPtoken)) / 1e18);
}
staker_.lastSnapshotIndex = uint32(latestSnapshotIdx);
}
return staker_;
}
function _claim(StakerSeat memory staker_, uint newEpoch_) private returns (StakerSeat memory) {
if (staker_.rewardEarned > 0) {
require(staker_.epochTimerStart + rewardLockupEpochs <= newEpoch_,
"Forest: you're still in reward lockup");
staker_.epochTimerStart = uint32(newEpoch_); // reset timer
IERC20(tree).transfer(msg.sender, staker_.rewardEarned); // we trust tree (no re-entrancy)
emit RewardPaid(msg.sender, uint80(staker_.rewardEarned));
staker_.rewardEarned = 0;
}
return staker_;
}
}
| 318,487 | 871 |
f88f8052a2cfe492fea601b60d8d6cbe1a585834b71f2a42aef7063f96cfdb58
| 23,991 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWDT4doqgiAxfMRUC1apZVmBXfSevjaAWS_VoucherDividend.sol
| 4,412 | 17,511 |
//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 vouchersBurnedAllTime() external returns (uint256);
function changeMintingBasePriceWhileDivDistro() external returns (bool);
function usersVoucherBurnedAmount(address user,uint256 mintShareStatus) 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;
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).vouchersBurnedAllTime();
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){
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, uint256 dividedAmount) 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).vouchersBurnedAllTime();
//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;
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 withdraw
uint256 totalTokensTRC20 = whitelistCallerArray.length;
for(uint64 i=0; i < totalTokensTRC20; i++){
address tokenAddress = whitelistCallerArray[i];
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
for(i=0; i < totalTokensTRC20; i++){
divPaidAllTimeUsersTRC20[user][whitelistCallerArray[i]] = divPaidAllTime[whitelistCallerArray[i]];
}
//Updating user's dividend tracker END ---------------------
return true;
}
function userConfirmedDividendTRX(address user) public view returns(uint256){
uint256 userVouchersBurned = InterfaceVoucherTOKEN(voucherTokenContract).usersVoucherBurnedAmount(user,2);
//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,2);
//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_) public onlyOwner returns(string){
voucherTokenContract = voucherTokenContract_;
return("contract address updated successfully");
}
}
| 293,085 | 872 |
0cd76011d073aba46ad34403576fbc094c513214b72d43241468e24c51a520b0
| 12,041 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2cccc3f5351c916b0e92c72af007641551c96bfa.sol
| 3,219 | 10,475 |
pragma solidity ^0.4.19;
contract CrowdsaleTokenInterface {
uint public decimals;
function addLockAddress(address addr, uint lock_time) public;
function mint(address _to, uint256 _amount) public returns (bool);
function finishMinting() public returns (bool);
}
contract CrowdsaleLimit {
using SafeMath for uint256;
// the UNIX timestamp start date of the crowdsale
uint public startsAt;
// the UNIX timestamp end date of the crowdsale
uint public endsAt;
uint public token_decimals = 8;
uint public TOKEN_RATE_PRESALE = 7200;
uint public TOKEN_RATE_CROWDSALE= 6000;
// setting the wei value for one token in presale stage
uint public PRESALE_TOKEN_IN_WEI = 1 ether / TOKEN_RATE_PRESALE;
// setting the wei value for one token in crowdsale stage
uint public CROWDSALE_TOKEN_IN_WEI = 1 ether / TOKEN_RATE_CROWDSALE;
// setting the max fund of presale with eth
uint public PRESALE_ETH_IN_WEI_FUND_MAX = 40000 ether;
// setting the min fund of crowdsale with eth
uint public CROWDSALE_ETH_IN_WEI_FUND_MIN = 22000 ether;
// setting the max fund of crowdsale with eth
uint public CROWDSALE_ETH_IN_WEI_FUND_MAX = 90000 ether;
// setting the min acceptable invest with eth in presale
uint public PRESALE_ETH_IN_WEI_ACCEPTED_MIN = 1 ether;
// setting the min acceptable invest with eth in pubsale
uint public CROWDSALE_ETH_IN_WEI_ACCEPTED_MIN = 100 finney;
// setting the gasprice to limit big buyer, default to disable
uint public CROWDSALE_GASPRICE_IN_WEI_MAX = 0;
// total eth fund in presale stage
uint public presale_eth_fund= 0;
// total eth fund
uint public crowdsale_eth_fund= 0;
// total eth refund
uint public crowdsale_eth_refund = 0;
// setting team list and set percentage of tokens
mapping(address => uint) public team_addresses_token_percentage;
mapping(uint => address) public team_addresses_idx;
uint public team_address_count= 0;
uint public team_token_percentage_total= 0;
uint public team_token_percentage_max= 40;
event EndsAtChanged(uint newEndsAt);
event AddTeamAddress(address addr, uint release_time, uint token_percentage);
event Refund(address investor, uint weiAmount);
// limitation of buying tokens
modifier allowCrowdsaleAmountLimit(){
if (msg.value == 0) revert();
if((crowdsale_eth_fund.add(msg.value)) > CROWDSALE_ETH_IN_WEI_FUND_MAX) revert();
if((CROWDSALE_GASPRICE_IN_WEI_MAX > 0) && (tx.gasprice > CROWDSALE_GASPRICE_IN_WEI_MAX)) revert();
_;
}
function CrowdsaleLimit(uint _start, uint _end) public {
require(_start != 0);
require(_end != 0);
require(_start < _end);
startsAt = _start;
endsAt = _end;
}
// caculate amount of token in presale stage
function calculateTokenPresale(uint value, uint decimals) public constant returns (uint) {
uint multiplier = 10 ** decimals;
return value.mul(multiplier).div(PRESALE_TOKEN_IN_WEI);
}
// caculate amount of token in crowdsale stage
function calculateTokenCrowsale(uint value, uint decimals) public constant returns (uint) {
uint multiplier = 10 ** decimals;
return value.mul(multiplier).div(CROWDSALE_TOKEN_IN_WEI);
}
// check if the goal is reached
function isMinimumGoalReached() public constant returns (bool) {
return crowdsale_eth_fund >= CROWDSALE_ETH_IN_WEI_FUND_MIN;
}
// add new team percentage of tokens
function addTeamAddressInternal(address addr, uint release_time, uint token_percentage) internal {
if((team_token_percentage_total.add(token_percentage)) > team_token_percentage_max) revert();
if((team_token_percentage_total.add(token_percentage)) > 100) revert();
if(team_addresses_token_percentage[addr] != 0) revert();
team_addresses_token_percentage[addr]= token_percentage;
team_addresses_idx[team_address_count]= addr;
team_address_count++;
team_token_percentage_total = team_token_percentage_total.add(token_percentage);
AddTeamAddress(addr, release_time, token_percentage);
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return now > endsAt;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) 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 Crowdsale is CrowdsaleLimit, Haltable {
using SafeMath for uint256;
CrowdsaleTokenInterface public token;
address public multisigWallet;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
uint public tokensSold = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
bool public finalized;
enum State{Unknown, PreFunding, Funding, Success, Failure, Finalized, Refunding}
// A new investment was made
event Invested(address investor, uint weiAmount, uint tokenAmount);
event createTeamTokenEvent(address addr, uint tokens);
event Finalized();
modifier inState(State state) {
if(getState() != state) revert();
_;
}
function Crowdsale(address _token, address _multisigWallet, uint _start, uint _end) CrowdsaleLimit(_start, _end) public
{
require(_token != 0x0);
require(_multisigWallet != 0x0);
token = CrowdsaleTokenInterface(_token);
if(token_decimals != token.decimals()) revert();
multisigWallet = _multisigWallet;
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (now < startsAt) return State.PreFunding;
else if (now <= endsAt && !isMinimumGoalReached()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && crowdsale_eth_fund > 0 && loadedRefund >= crowdsale_eth_fund) return State.Refunding;
else return State.Failure;
}
//add new team percentage of tokens and lock their release time
function addTeamAddress(address addr, uint release_time, uint token_percentage) onlyOwner inState(State.PreFunding) public {
super.addTeamAddressInternal(addr, release_time, token_percentage);
token.addLockAddress(addr, release_time); //not use delegatecall
}
//generate team tokens in accordance with percentage of total issue tokens, not preallocate
function createTeamTokenByPercentage() onlyOwner internal {
//uint total= token.totalSupply();
uint total= tokensSold;
//uint tokens= total.mul(100).div(100-team_token_percentage_total).sub(total);
uint tokens= total.mul(team_token_percentage_total).div(100-team_token_percentage_total);
for(uint i=0; i<team_address_count; i++) {
address addr= team_addresses_idx[i];
if(addr==0x0) continue;
uint ntoken= tokens.mul(team_addresses_token_percentage[addr]).div(team_token_percentage_total);
token.mint(addr, ntoken);
createTeamTokenEvent(addr, ntoken);
}
}
// fallback function can be used to buy tokens
function () stopInEmergency allowCrowdsaleAmountLimit payable public {
require(msg.sender != 0x0);
buyTokensCrowdsale(msg.sender);
}
// low level token purchase function
function buyTokensCrowdsale(address receiver) internal {
uint256 weiAmount = msg.value;
uint256 tokenAmount= 0;
if(getState() == State.PreFunding) {
if (weiAmount < PRESALE_ETH_IN_WEI_ACCEPTED_MIN) revert();
if((PRESALE_ETH_IN_WEI_FUND_MAX > 0) && ((presale_eth_fund.add(weiAmount)) > PRESALE_ETH_IN_WEI_FUND_MAX)) revert();
tokenAmount = calculateTokenPresale(weiAmount, token_decimals);
presale_eth_fund = presale_eth_fund.add(weiAmount);
}
else if((getState() == State.Funding) || (getState() == State.Success)) {
if (weiAmount < CROWDSALE_ETH_IN_WEI_ACCEPTED_MIN) revert();
tokenAmount = calculateTokenCrowsale(weiAmount, token_decimals);
} else {
// Unwanted state
revert();
}
if(tokenAmount == 0) {
revert();
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
// Update investor
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
// Update totals
crowdsale_eth_fund = crowdsale_eth_fund.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
token.mint(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) revert();
// Tell us invest was success
Invested(receiver, weiAmount, tokenAmount);
}
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;
crowdsale_eth_refund = crowdsale_eth_refund.add(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) revert();
}
function setEndsAt(uint time) onlyOwner public {
if(now > time) {
revert();
}
endsAt = time;
EndsAtChanged(endsAt);
}
// should be called after crowdsale ends, to do
// some extra finalization work
function doFinalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
revert();
}
createTeamTokenByPercentage();
token.finishMinting();
finalized = true;
Finalized();
}
}
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;
}
}
| 211,726 | 873 |
da5d96becdb42c29a95baf9f82dbd7f470613fe0992955403393901df943b5c6
| 23,222 |
.sol
|
Solidity
| false |
440001955
|
ParrotDao/Contracts
|
7475422b07ea75f120ec941916070da8a180e99a
|
Treasury.sol
| 5,674 | 22,420 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
function mul32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require(x == 0 || (z = x * y) / x == y);
}
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
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 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);
}
}
}
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);
}
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
require(newOwner != address(0) || renounce, "Ownable: zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
pendingOwner = newOwner;
}
}
function claimOwnership() public {
address _pendingOwner = pendingOwner;
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _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");
}
}
}
interface IERC20Mintable {
function mint(uint256 amount_) external;
function mint(address account_, uint256 ammount_) external;
}
interface ITIMEERC20 is IERC20Mintable, IERC20 {
function burnFrom(address account_, uint256 amount_) external;
}
interface IBondCalculator {
function valuation(address pair_, uint amount_) external view returns (uint _value);
}
contract ParrotTreasury is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
event Deposit(address indexed token, uint amount, uint value);
event Withdrawal(address indexed token, uint amount, uint value);
event CreateDebt(address indexed debtor, address indexed token, uint amount, uint value);
event RepayDebt(address indexed debtor, address indexed token, uint amount, uint value);
event ReservesManaged(address indexed token, uint amount);
event ReservesUpdated(uint indexed totalReserves);
event ReservesAudited(uint indexed totalReserves);
event RewardsMinted(address indexed caller, address indexed recipient, uint amount);
event ChangeQueued(MANAGING indexed managing, address queued);
event ChangeActivated(MANAGING indexed managing, address activated, bool result);
event ChangeLimitAmount(uint256 amount);
enum MANAGING {
RESERVEDEPOSITOR,
RESERVESPENDER,
RESERVETOKEN,
RESERVEMANAGER,
LIQUIDITYDEPOSITOR,
LIQUIDITYTOKEN,
LIQUIDITYMANAGER,
DEBTOR,
REWARDMANAGER,
SOHM
}
ITIMEERC20 public immutable Time;
uint32 public immutable secondsNeededForQueue;
address[] public reserveTokens;
mapping(address => bool) public isReserveToken;
mapping(address => uint32) public reserveTokenQueue;
address[] public reserveDepositors;
mapping(address => bool) public isReserveDepositor;
mapping(address => uint32) public reserveDepositorQueue;
address[] public reserveSpenders;
mapping(address => bool) public isReserveSpender;
mapping(address => uint32) public reserveSpenderQueue;
address[] public liquidityTokens;
mapping(address => bool) public isLiquidityToken;
mapping(address => uint32) public LiquidityTokenQueue;
address[] public liquidityDepositors;
mapping(address => bool) public isLiquidityDepositor;
mapping(address => uint32) public LiquidityDepositorQueue;
mapping(address => address) public bondCalculator;
address[] public reserveManagers;
mapping(address => bool) public isReserveManager;
mapping(address => uint32) public ReserveManagerQueue;
address[] public liquidityManagers;
mapping(address => bool) public isLiquidityManager;
mapping(address => uint32) public LiquidityManagerQueue;
address[] public debtors;
mapping(address => bool) public isDebtor;
mapping(address => uint32) public debtorQueue;
mapping(address => uint) public debtorBalance;
address[] public rewardManagers;
mapping(address => bool) public isRewardManager;
mapping(address => uint32) public rewardManagerQueue;
mapping(address => uint256) public hourlyLimitAmounts;
mapping(address => uint32) public hourlyLimitQueue;
uint256 public limitAmount;
IERC20 public MEMOries;
uint public sOHMQueue;
uint public totalReserves;
uint public totalDebt;
constructor (address _Parrot,
address _MIM,
uint32 _secondsNeededForQueue,
uint256 _limitAmount) {
require(_Parrot != address(0));
Time = ITIMEERC20(_Parrot);
isReserveToken[ _MIM ] = true;
reserveTokens.push(_MIM);
secondsNeededForQueue = _secondsNeededForQueue;
limitAmount = _limitAmount;
}
function setLimitAmount(uint amount) external onlyOwner {
limitAmount = amount;
emit ChangeLimitAmount(limitAmount);
}
function deposit(uint _amount, address _token, uint _profit) external returns (uint send_) {
require(isReserveToken[ _token ] || isLiquidityToken[ _token ], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
if (isReserveToken[ _token ]) {
require(isReserveDepositor[ msg.sender ], "Not approved");
} else {
require(isLiquidityDepositor[ msg.sender ], "Not approved");
}
uint value = valueOf(_token, _amount);
send_ = value.sub(_profit);
limitRequirements(msg.sender, send_);
Time.mint(msg.sender, send_);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit Deposit(_token, _amount, value);
}
function withdraw(uint _amount, address _token) external {
require(isReserveToken[ _token ], "Not accepted");
require(isReserveSpender[ msg.sender ], "Not approved");
uint value = valueOf(_token, _amount);
Time.burnFrom(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit Withdrawal(_token, _amount, value);
}
function incurDebt(uint _amount, address _token) external {
require(isDebtor[ msg.sender ], "Not approved");
require(isReserveToken[ _token ], "Not accepted");
uint value = valueOf(_token, _amount);
uint maximumDebt = MEMOries.balanceOf(msg.sender);
uint balance = debtorBalance[ msg.sender ];
uint availableDebt = maximumDebt.sub(balance);
require(value <= availableDebt, "Exceeds debt limit");
limitRequirements(msg.sender, value);
debtorBalance[ msg.sender ] = balance.add(value);
totalDebt = totalDebt.add(value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit CreateDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithReserve(uint _amount, address _token) external {
require(isDebtor[ msg.sender ], "Not approved");
require(isReserveToken[ _token ], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
uint value = valueOf(_token, _amount);
debtorBalance[ msg.sender ] = debtorBalance[ msg.sender ].sub(value);
totalDebt = totalDebt.sub(value);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit RepayDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithTime(uint _amount) external {
require(isDebtor[ msg.sender ], "Not approved as debtor");
require(isReserveSpender[ msg.sender ], "Not approved as spender");
Time.burnFrom(msg.sender, _amount);
debtorBalance[ msg.sender ] = debtorBalance[ msg.sender ].sub(_amount);
totalDebt = totalDebt.sub(_amount);
emit RepayDebt(msg.sender, address(Time), _amount, _amount);
}
function manage(address _token, uint _amount) external {
uint value = valueOf(_token, _amount);
if(isLiquidityToken[ _token ]) {
require(isLiquidityManager[ msg.sender ], "Not approved");
require(value <= excessReserves());
} else {
if (isReserveToken[ _token ]) require(value <= excessReserves());
require(isReserveManager[ msg.sender ], "Not approved");
}
limitRequirements(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit ReservesManaged(_token, _amount);
}
function mintRewards(address _recipient, uint _amount) external {
require(isRewardManager[ msg.sender ], "Not approved");
require(_amount <= excessReserves(), "Insufficient reserves");
limitRequirements(msg.sender, _amount);
Time.mint(_recipient, _amount);
emit RewardsMinted(msg.sender, _recipient, _amount);
}
function excessReserves() public view returns (uint) {
return totalReserves.sub(Time.totalSupply().sub(totalDebt));
}
function auditReserves() external onlyOwner {
uint reserves;
for(uint i = 0; i < reserveTokens.length; i++) {
reserves = reserves.add (valueOf(reserveTokens[ i ], IERC20(reserveTokens[ i ]).balanceOf(address(this))));
}
for(uint i = 0; i < liquidityTokens.length; i++) {
reserves = reserves.add (valueOf(liquidityTokens[ i ], IERC20(liquidityTokens[ i ]).balanceOf(address(this))));
}
totalReserves = reserves;
emit ReservesUpdated(reserves);
emit ReservesAudited(reserves);
}
function valueOf(address _token, uint _amount) public view returns (uint value_) {
if (isReserveToken[ _token ]) {
value_ = _amount.mul(10 ** Time.decimals()).div(10 ** IERC20(_token).decimals());
} else if (isLiquidityToken[ _token ]) {
value_ = IBondCalculator(bondCalculator[ _token ]).valuation(_token, _amount);
}
}
function queue(MANAGING _managing, address _address) external onlyOwner returns (bool) {
require(_address != address(0), "IA");
if (_managing == MANAGING.RESERVEDEPOSITOR) { // 0
reserveDepositorQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.RESERVESPENDER) { // 1
reserveSpenderQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.RESERVETOKEN) { // 2
reserveTokenQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.RESERVEMANAGER) { // 3
ReserveManagerQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue.mul32(2));
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) { // 4
LiquidityDepositorQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYTOKEN) { // 5
LiquidityTokenQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYMANAGER) { // 6
LiquidityManagerQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue.mul32(2));
} else if (_managing == MANAGING.DEBTOR) { // 7
debtorQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.REWARDMANAGER) { // 8
rewardManagerQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.SOHM) { // 9
sOHMQueue = uint32(block.timestamp).add32(secondsNeededForQueue);
} else return false;
emit ChangeQueued(_managing, _address);
return true;
}
function toggle(MANAGING _managing,
address _address,
address _calculator) external onlyOwner returns (bool) {
require(_address != address(0), "IA");
bool result;
if (_managing == MANAGING.RESERVEDEPOSITOR) { // 0
if (requirements(reserveDepositorQueue, isReserveDepositor, _address)) {
reserveDepositorQueue[ _address ] = 0;
if(!listContains(reserveDepositors, _address)) {
reserveDepositors.push(_address);
}
}
result = !isReserveDepositor[ _address ];
isReserveDepositor[ _address ] = result;
} else if (_managing == MANAGING.RESERVESPENDER) { // 1
if (requirements(reserveSpenderQueue, isReserveSpender, _address)) {
reserveSpenderQueue[ _address ] = 0;
if(!listContains(reserveSpenders, _address)) {
reserveSpenders.push(_address);
}
}
result = !isReserveSpender[ _address ];
isReserveSpender[ _address ] = result;
} else if (_managing == MANAGING.RESERVETOKEN) { // 2
if (requirements(reserveTokenQueue, isReserveToken, _address)) {
reserveTokenQueue[ _address ] = 0;
if(!listContains(reserveTokens, _address) && !listContains(liquidityTokens, _address)) {
reserveTokens.push(_address);
}
}
result = !isReserveToken[ _address ];
require(!result || !isLiquidityToken[_address], "Do not add to both types of token");
isReserveToken[ _address ] = result;
} else if (_managing == MANAGING.RESERVEMANAGER) { // 3
if (requirements(ReserveManagerQueue, isReserveManager, _address)) {
reserveManagers.push(_address);
ReserveManagerQueue[ _address ] = 0;
if(!listContains(reserveManagers, _address)) {
reserveManagers.push(_address);
}
}
result = !isReserveManager[ _address ];
isReserveManager[ _address ] = result;
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) { // 4
if (requirements(LiquidityDepositorQueue, isLiquidityDepositor, _address)) {
liquidityDepositors.push(_address);
LiquidityDepositorQueue[ _address ] = 0;
if(!listContains(liquidityDepositors, _address)) {
liquidityDepositors.push(_address);
}
}
result = !isLiquidityDepositor[ _address ];
isLiquidityDepositor[ _address ] = result;
} else if (_managing == MANAGING.LIQUIDITYTOKEN) { // 5
if (requirements(LiquidityTokenQueue, isLiquidityToken, _address)) {
LiquidityTokenQueue[ _address ] = 0;
if(!listContains(liquidityTokens, _address) && !listContains(reserveTokens, _address)) {
liquidityTokens.push(_address);
}
}
result = !isLiquidityToken[ _address ];
require(!result || !isReserveToken[_address], "Do not add to both types of token");
isLiquidityToken[ _address ] = result;
bondCalculator[ _address ] = _calculator;
} else if (_managing == MANAGING.LIQUIDITYMANAGER) { // 6
if (requirements(LiquidityManagerQueue, isLiquidityManager, _address)) {
LiquidityManagerQueue[ _address ] = 0;
if(!listContains(liquidityManagers, _address)) {
liquidityManagers.push(_address);
}
}
result = !isLiquidityManager[ _address ];
isLiquidityManager[ _address ] = result;
} else if (_managing == MANAGING.DEBTOR) { // 7
if (requirements(debtorQueue, isDebtor, _address)) {
debtorQueue[ _address ] = 0;
if(!listContains(debtors, _address)) {
debtors.push(_address);
}
}
result = !isDebtor[ _address ];
isDebtor[ _address ] = result;
} else if (_managing == MANAGING.REWARDMANAGER) { // 8
if (requirements(rewardManagerQueue, isRewardManager, _address)) {
rewardManagerQueue[ _address ] = 0;
if(!listContains(rewardManagers, _address)) {
rewardManagers.push(_address);
}
}
result = !isRewardManager[ _address ];
isRewardManager[ _address ] = result;
} else if (_managing == MANAGING.SOHM) { // 9
sOHMQueue = 0;
MEMOries = IERC20(_address);
result = true;
} else return false;
emit ChangeActivated(_managing, _address, result);
return true;
}
function requirements(mapping(address => uint32) storage queue_,
mapping(address => bool) storage status_,
address _address) internal view returns (bool) {
if (!status_[ _address ]) {
require(queue_[ _address ] != 0, "Must queue");
require(queue_[ _address ] <= uint32(block.timestamp), "Queue not expired");
return true;
} return false;
}
function limitRequirements(address _address,
uint256 value) internal {
if (block.timestamp.sub(hourlyLimitQueue[_address]) >= 1 hours)
{
hourlyLimitAmounts[_address] = limitAmount;
hourlyLimitQueue[_address] = uint32(block.timestamp);
}
hourlyLimitAmounts[_address] = hourlyLimitAmounts[_address].sub(value);
}
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for(uint i = 0; i < _list.length; i++) {
if(_list[ i ] == _token) {
return true;
}
}
return false;
}
}
| 19,700 | 874 |
9751cf07b1c0380eae8225b2cabb1894cfa5bf63274c5e78376d26ef37f856ea
| 21,487 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/cf/cF60840aCF498e11ab68b93c76dCd3Af69a61a07_BribeFactory.sol
| 3,891 | 15,318 |
pragma solidity 0.5.17;
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;
}
}
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 Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract Pausable is Owned {
uint public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused, "This action cannot be performed while the contract is paused");
_;
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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 Bribe is ReentrancyGuard, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint public constant DURATION = 7 days; // rewards are released over 7 days
struct Reward {
uint256 rewardsDuration;
uint256 periodFinish;
uint256 rewardRate;
uint256 lastUpdateTime;
uint256 rewardPerTokenStored;
}
mapping(address => Reward) public rewardData;
mapping(address => bool) public isRewardToken;
address[] public rewardTokens;
address public gaugeProxy;
address public bribeFactory;
// user -> reward token -> amount
mapping(address => mapping(address => uint256)) public userRewardPerTokenPaid;
mapping(address => mapping(address => uint256)) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _owner,
address _gaugeProxy,
address _bribeFactory) public Owned(_owner) {
gaugeProxy = _gaugeProxy;
bribeFactory = _bribeFactory;
}
function addReward(address _rewardsToken) public {
require((msg.sender == owner || msg.sender == gaugeProxy || msg.sender == bribeFactory),
"addReward: permission is denied!");
require(!isRewardToken[_rewardsToken], "Reward token already exists");
//require(rewardData[_rewardsToken].rewardsDuration == 0, "Reward token already exists");
isRewardToken[_rewardsToken] = true;
rewardTokens.push(_rewardsToken);
rewardData[_rewardsToken].rewardsDuration = DURATION;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable(address _rewardsToken) public view returns (uint256) {
return Math.min(block.timestamp, rewardData[_rewardsToken].periodFinish);
}
function rewardPerToken(address _rewardsToken) public view returns (uint256) {
if (_totalSupply == 0) {
return rewardData[_rewardsToken].rewardPerTokenStored;
}
return
rewardData[_rewardsToken].rewardPerTokenStored.add(lastTimeRewardApplicable(_rewardsToken).sub(rewardData[_rewardsToken].lastUpdateTime).mul(rewardData[_rewardsToken].rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account, address _rewardsToken) public view returns (uint256) {
return _balances[account].mul(rewardPerToken(_rewardsToken).sub(userRewardPerTokenPaid[account][_rewardsToken])).div(1e18).add(rewards[account][_rewardsToken]);
}
function getRewardForDuration(address _rewardsToken) external view returns (uint256) {
return rewardData[_rewardsToken].rewardRate.mul(rewardData[_rewardsToken].rewardsDuration);
}
function _deposit(uint256 amount, address voter) external nonReentrant notPaused updateReward(voter) {
require(amount > 0, "Cannot stake 0");
require(msg.sender == gaugeProxy);
_totalSupply = _totalSupply.add(amount);
_balances[voter] = _balances[voter].add(amount);
emit Staked(voter, amount);
}
function _withdraw(uint256 amount, address voter) public nonReentrant updateReward(voter) {
require(amount > 0, "Cannot withdraw 0");
require(msg.sender == gaugeProxy);
// incase of bribe contract reset in gauge proxy
if (amount <= _balances[voter]) {
_totalSupply = _totalSupply.sub(amount);
_balances[voter] = _balances[voter].sub(amount);
emit Withdrawn(voter, amount);
}
}
function getRewardForOwner(address voter) public nonReentrant updateReward(voter) {
for (uint i; i < rewardTokens.length; i++) {
address _rewardsToken = rewardTokens[i];
uint256 reward = rewards[voter][_rewardsToken];
if (reward > 0) {
rewards[voter][_rewardsToken] = 0;
IERC20(_rewardsToken).safeTransfer(voter, reward);
emit RewardPaid(voter, _rewardsToken, reward);
}
}
}
function notifyRewardAmount(address _rewardsToken, uint256 reward) external updateReward(address(0)) {
require(reward > 0, 'reward amount should be greater than 0');
require(isRewardToken[_rewardsToken], 'reward token not verified');
// handle the transfer of reward tokens via `transferFrom` to reduce the number
// of transactions required and ensure correctness of the reward amount
IERC20(_rewardsToken).safeTransferFrom(msg.sender, address(this), reward);
if (block.timestamp >= rewardData[_rewardsToken].periodFinish) {
rewardData[_rewardsToken].rewardRate = reward.div(rewardData[_rewardsToken].rewardsDuration);
} else {
uint256 remaining = rewardData[_rewardsToken].periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardData[_rewardsToken].rewardRate);
require(reward > leftover, 'reward amount should be greater than leftover amount'); // to stop griefing attack
rewardData[_rewardsToken].rewardRate = reward.add(leftover).div(rewardData[_rewardsToken].rewardsDuration);
}
rewardData[_rewardsToken].lastUpdateTime = block.timestamp;
rewardData[_rewardsToken].periodFinish = block.timestamp.add(rewardData[_rewardsToken].rewardsDuration);
emit RewardAdded(reward);
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
// require(rewardData[tokenAddress].lastUpdateTime == 0, "Cannot withdraw reward token");
IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
modifier updateReward(address account) {
for (uint i; i < rewardTokens.length; i++) {
address token = rewardTokens[i];
rewardData[token].rewardPerTokenStored = rewardPerToken(token);
rewardData[token].lastUpdateTime = lastTimeRewardApplicable(token);
if (account != address(0)) {
rewards[account][token] = earned(account, token);
userRewardPerTokenPaid[account][token] = rewardData[token].rewardPerTokenStored;
}
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, address indexed rewardsToken, uint256 reward);
event RewardsDurationUpdated(address token, uint256 newDuration);
event Recovered(address token, uint256 amount);
}
contract BribeFactory {
address public last_bribe;
function createBribe(address _owner, address _tokenLP, address _token0, address _token1) external returns (address) {
Bribe lastBribe = new Bribe(_owner, msg.sender, address(this));
lastBribe.addReward(_tokenLP);
lastBribe.addReward(_token0);
lastBribe.addReward(_token1);
last_bribe = address(lastBribe);
return last_bribe;
}
}
| 307,351 | 875 |
9b0927aebb27021943202b37ae3e54705622882a50605a11810e25f32291d0b7
| 22,157 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Integer_overflow_and_underflow/SolidifiResult/buggy_34.sol
| 4,899 | 15,753 |
pragma solidity >=0.5.11;
contract Ownable {
mapping(address => uint) public lockTime_intou5;
function increaseLockTime_intou5(uint _secondsToIncrease) public {
lockTime_intou5[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou5() public {
require(now > lockTime_intou5[msg.sender]);
uint transferValue_intou5 = 10;
msg.sender.transfer(transferValue_intou5);
}
address payable public owner;
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
function bug_intou31() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
}
mapping(address => uint) balances_intou30;
function transfer_intou30(address _to, uint _value) public returns (bool) {
require(balances_intou30[msg.sender] - _value >= 0); //bug
balances_intou30[msg.sender] -= _value; //bug
balances_intou30[_to] += _value; //bug
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) {
// 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;
function bug_intou40(uint8 p_intou40) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou40; // overflow bug
}
mapping (address => transferMapping) private _balances;
function bug_intou4(uint8 p_intou4) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou4; // overflow bug
}
mapping (address => mapping (address => uint256)) private _allowances;
function bug_intou39() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
uint256 private _totalSupply;
mapping(address => uint) balances_intou38;
function transfer_intou38(address _to, uint _value) public returns (bool) {
require(balances_intou38[msg.sender] - _value >= 0); //bug
balances_intou38[msg.sender] -= _value; //bug
balances_intou38[_to] += _value; //bug
return true;
}
uint256 public _maxTotalSupply;
mapping(address => uint) public lockTime_intou37;
function increaseLockTime_intou37(uint _secondsToIncrease) public {
lockTime_intou37[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou37() public {
require(now > lockTime_intou37[msg.sender]);
uint transferValue_intou37 = 10;
msg.sender.transfer(transferValue_intou37);
}
string private _name = "Lollypop";
function bug_intou36(uint8 p_intou36) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou36; // overflow bug
}
string private _symbol = "Lolly";
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
uint8 private _decimals= 18;
mapping(address => uint) balances_intou34;
function transfer_intou34(address _to, uint _value) public returns (bool) {
require(balances_intou34[msg.sender] - _value >= 0); //bug
balances_intou34[msg.sender] -= _value; //bug
balances_intou34[_to] += _value; //bug
return true;
}
uint256 public maxAgeOfToken = 365 days;
mapping(address => uint) public lockTime_intou33;
function increaseLockTime_intou33(uint _secondsToIncrease) public {
lockTime_intou33[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou33() public {
require(now > lockTime_intou33[msg.sender]);
uint transferValue_intou33 = 10;
msg.sender.transfer(transferValue_intou33);
}
uint256 public minAgeOfToken = 1 days;
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug
}
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;
}
function bug_intou3() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
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;
}
mapping(address => uint) public lockTime_intou29;
function increaseLockTime_intou29(uint _secondsToIncrease) public {
lockTime_intou29[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou29() public {
require(now > lockTime_intou29[msg.sender]);
uint transferValue_intou29 = 10;
msg.sender.transfer(transferValue_intou29);
}
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_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug
}
function name() public view returns (string memory) {
return _name;
}
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
function symbol() public view returns (string memory) {
return _symbol;
}
mapping(address => uint) balances_intou26;
function transfer_intou26(address _to, uint _value) public returns (bool) {
require(balances_intou26[msg.sender] - _value >= 0); //bug
balances_intou26[msg.sender] -= _value; //bug
balances_intou26[_to] += _value; //bug
return true;
}
function decimals() public view returns (uint8) {
return _decimals;
}
mapping(address => uint) public lockTime_intou25;
function increaseLockTime_intou25(uint _secondsToIncrease) public {
lockTime_intou25[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou25() public {
require(now > lockTime_intou25[msg.sender]);
uint transferValue_intou25 = 10;
msg.sender.transfer(transferValue_intou25);
}
modifier onlyLollypopAndOwner {
require(msg.sender == address(this) || msg.sender == owner);
_;
}
mapping(address => uint) balances_intou10;
function transfer_intou10(address _to, uint _value) public returns (bool) {
require(balances_intou10[msg.sender] - _value >= 0); //bug
balances_intou10[msg.sender] -= _value; //bug
balances_intou10[_to] += _value; //bug
return true;
}
event Transfer(address indexed from, address indexed to, uint256 value);
mapping(address => uint) public lockTime_intou1;
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_ovrflow1() public {
require(now > lockTime_intou1[msg.sender]);
uint transferValue_intou1 = 10;
msg.sender.transfer(transferValue_intou1);
}
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_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account].amount;
}
mapping(address => uint) balances_intou22;
function transfer_intou22(address _to, uint _value) public returns (bool) {
require(balances_intou22[msg.sender] - _value >= 0); //bug
balances_intou22[msg.sender] -= _value; //bug
balances_intou22[_to] += _value; //bug
return true;
}
function timeOf(address account) public view returns (uint256) {
return _balances[account].time;
}
mapping(address => uint) public lockTime_intou21;
function increaseLockTime_intou21(uint _secondsToIncrease) public {
lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou21() public {
require(now > lockTime_intou21[msg.sender]);
uint transferValue_intou21 = 10;
msg.sender.transfer(transferValue_intou21);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug
}
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]);
}
}
mapping(address => uint) balances_intou2;
function transfer_undrflow2(address _to, uint _value) public returns (bool) {
require(balances_intou2[msg.sender] - _value >= 0); //bug
balances_intou2[msg.sender] -= _value; //bug
balances_intou2[_to] += _value; //bug
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
mapping(address => uint) balances_intou18;
function transfer_intou18(address _to, uint _value) public returns (bool) {
require(balances_intou18[msg.sender] - _value >= 0); //bug
balances_intou18[msg.sender] -= _value; //bug
balances_intou18[_to] += _value; //bug
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
mapping(address => uint) public lockTime_intou17;
function increaseLockTime_intou17(uint _secondsToIncrease) public {
lockTime_intou17[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou17() public {
require(now > lockTime_intou17[msg.sender]);
uint transferValue_intou17 = 10;
msg.sender.transfer(transferValue_intou17);
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
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);
}
mapping(address => uint) balances_intou14;
function transfer_intou14(address _to, uint _value) public returns (bool) {
require(balances_intou14[msg.sender] - _value >= 0); //bug
balances_intou14[msg.sender] -= _value; //bug
balances_intou14[_to] += _value; //bug
return true;
}
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);
}
mapping(address => uint) public lockTime_intou13;
function increaseLockTime_intou13(uint _secondsToIncrease) public {
lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou13() public {
require(now > lockTime_intou13[msg.sender]);
uint transferValue_intou13 = 10;
msg.sender.transfer(transferValue_intou13);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug
}
}
| 223,823 | 876 |
d358c69cbe9fac47a09959df235a6cb82a1728862629f3fe9fbfc4f59b8af967
| 30,442 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable_flat.sol
| 3,420 | 13,546 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/ECDSA.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
library ECDSAUpgradeable {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
abstract contract EIP712Upgradeable is Initializable {
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function _EIP712NameHash() internal virtual view returns (bytes32) {
return _HASHED_NAME;
}
function _EIP712VersionHash() internal virtual view returns (bytes32) {
return _HASHED_VERSION;
}
uint256[50] private __gap;
}
| 63,272 | 877 |
7236a005aac926ffa81b98830a0b037eea85ecd7b3f6bcdd72fa3d14b6537346
| 19,836 |
.sol
|
Solidity
| false |
302093770
|
HODLCommunity/HODLDex2
|
941ab6fb40fc8c4b4ce95f5866618f6367812249
|
contracts/libraries/Proportional.sol
| 3,422 | 14,985 |
pragma solidity 0.6.6;
// SPDX-License-Identifier: Unlicensed
import "@openzeppelin/contracts/math/SafeMath.sol";
interface ProportionalInterface {
function circulatingSupply() external view returns(uint amount);
}
library Proportional {
using SafeMath for uint;
uint constant PRECISION = 10 ** 18;
struct System {
uint birthday;
uint periodicity;
address source;
bytes32 shareAsset; // The asset used to determine shares, e.g. use HODL shares to distribute Eth proportionally.
mapping(bytes32 => Asset) asset;
}
struct Asset {
Distribution[] distributions;
mapping(address => User) users;
}
struct Distribution {
uint denominator; // Usually the supply, used to calculate user shares, e.g. balance / circulating supply
uint amount; // The distribution amount. Accumulates allocations. Does not decrement with claims.
uint period; // Timestamp when the accounting period was closed.
}
struct User {
UserBalance[] userBalances;
uint processingDistributionIndex; // The next distribution of *this asset* to process for the user.
uint processingBalanceIndex; // The *shareAsset* balance record to use to compute user shares for the next distribution.
}
struct UserBalance {
uint balance; // Last observed user balance in an accounting period
uint controlled; // Additional funds controlled the the user, e.g. escrowed, time-locked, open sell orders
uint period; // The period observed
}
event IncreaseDistribution(address sender, bytes32 indexed assetId, uint period, uint amount);
event DistributionClosed(address sender, bytes32 indexed assetId, uint distributionAmount, uint denominator, uint closedPeriod, uint newPeriod);
event DistributionPaid(address indexed receiver, bytes32 indexed assetId, uint period, uint amount, uint balanceIndex, uint distributionIndex);
event UserBalanceIncreased(address indexed sender, bytes32 indexed assetId, uint period, address user, uint toBalance, uint toControlled);
event UserBalanceReduced(address indexed sender, bytes32 indexed assetId, uint period, address user, uint fromBalance, uint fromControlled);
event UserFastForward(address indexed sender, bytes32 indexed assetId, uint balanceIndex);
function init(System storage self, bytes32[] storage assetId, bytes32 shareAssetId, uint birthday, uint periodicity, address source) internal {
Distribution memory d = Distribution({
denominator: 0,
amount: 0,
period: 0
});
self.shareAsset = shareAssetId;
self.birthday = birthday;
self.periodicity = periodicity;
self.source = source;
for(uint i=0; i<assetId.length; i++) {
Asset storage a = self.asset[assetId[i]];
a.distributions.push(d); // initialize with an open distribution in row 0.
}
}
function add(System storage self, bytes32 assetId, address user, uint toBalance, uint toControlled) internal {
Asset storage a = self.asset[assetId];
User storage u = a.users[user];
(uint currentBalance, uint balancePeriod, uint controlled) = userLatestBalanceUpdate(self, assetId, user);
uint balanceCount = u.userBalances.length;
uint p = period(self);
currentBalance = currentBalance.add(toBalance);
controlled = controlled.add(toControlled);
UserBalance memory b = UserBalance({
balance: currentBalance,
period: p,
controlled: controlled
});
emit UserBalanceIncreased(msg.sender, assetId, p, user, toBalance, toControlled);
if(balanceCount > 0 && (assetId != self.shareAsset || balancePeriod == p)) {
u.userBalances[balanceCount - 1] = b; // overwrite the last row;
return;
}
if(balanceCount == 0) {
u.processingDistributionIndex = distributionCount(self, assetId) - 1;
if(a.distributions[u.processingDistributionIndex].period < p) {
u.processingDistributionIndex++;
}
}
if(u.processingDistributionIndex == self.asset[assetId].distributions.length) {
u.processingBalanceIndex = u.userBalances.length;
}
u.userBalances.push(b);
return;
}
function sub(System storage self, bytes32 assetId, address user, uint fromBalance, uint fromControlled) internal {
Asset storage a = self.asset[assetId];
User storage u = a.users[user];
uint balanceCount = u.userBalances.length;
(uint currentBalance, uint balancePeriod, uint controlled) = userLatestBalanceUpdate(self, assetId, user);
uint p = period(self);
currentBalance = currentBalance.sub(fromBalance, "Prop NSF");
controlled = controlled.sub(fromControlled, "Prop nsf");
UserBalance memory b = UserBalance({
balance: currentBalance,
period: p,
controlled: controlled
});
emit UserBalanceReduced(msg.sender, assetId, p, user, fromBalance, fromControlled);
// re-use a userBalance row if possible
if(balanceCount > 0 && (assetId != self.shareAsset || balancePeriod == p)) {
u.userBalances[balanceCount - 1] = b;
return;
}
if(u.processingDistributionIndex == self.asset[assetId].distributions.length) {
u.processingBalanceIndex = u.userBalances.length;
}
// Append a new user balance row when we need to retain history or start a new user
u.userBalances.push(b); // start a new row
return;
}
function increaseDistribution(System storage self, bytes32 assetId, uint amount) internal {
Asset storage a = self.asset[assetId];
Distribution storage d = a.distributions[a.distributions.length - 1];
if(d.period < period(self)) {
_closeDistribution(self, assetId);
d = a.distributions[a.distributions.length - 1];
}
if(amount> 0) {
d.amount = d.amount.add(amount);
emit IncreaseDistribution(msg.sender, assetId, period(self), amount);
}
}
function _closeDistribution(System storage self, bytes32 assetId) private {
Asset storage a = self.asset[assetId];
Distribution storage d = a.distributions[a.distributions.length - 1];
uint p = period(self);
d.denominator = circulatingSupply(self);
Distribution memory newDist = Distribution({
denominator: 0,
amount: 0,
period: p
});
a.distributions.push(newDist);
emit DistributionClosed(msg.sender, assetId, d.amount, d.denominator, d.period, p);
}
// look ahead in accounting history
function peakNextUserBalancePeriod(User storage user, uint balanceIndex) private view returns(uint period) {
if(balanceIndex + 1 < user.userBalances.length) {
period = user.userBalances[balanceIndex + 1].period;
} else {
period = PRECISION; // never - this large number is a proxy for future, undefined
}
}
function peakNextDistributionPeriod(System storage self, uint distributionIndex) private view returns(uint period) {
Asset storage a = self.asset[self.shareAsset];
if(distributionIndex + 1 < a.distributions.length) {
period = a.distributions[distributionIndex + 1].period;
} else {
period = PRECISION - 1; // never - this large number is a proxy for future, undefined
}
}
function nudgeUserBalanceIndex(System storage self, bytes32 assetId, address user, uint balanceIndex) private {
if(balanceIndex < self.asset[self.shareAsset].users[user].userBalances.length) self.asset[assetId].users[user].processingBalanceIndex = balanceIndex + 1;
}
function nudgeUserDistributionIndex(System storage self, bytes32 assetId, address user, uint distributionIndex) private {
if(distributionIndex < self.asset[self.shareAsset].distributions.length) self.asset[assetId].users[user].processingDistributionIndex = distributionIndex + 1;
}
function processNextUserDistribution(System storage self, bytes32 assetId, address user) internal returns(uint amount) {
Asset storage a = self.asset[assetId];
Asset storage s = self.asset[self.shareAsset];
User storage ua = a.users[user];
User storage us = s.users[user];
poke(self, assetId);
// begin processing next distribution
uint balanceIndex;
uint distributionIndex;
bool closed;
(amount, balanceIndex, distributionIndex, closed) = nextUserDistributionDetails(self, assetId, user);
if(!closed) return 0;
Distribution storage d = a.distributions[distributionIndex];
// transfer the amount from the distribution to the user
emit DistributionPaid(msg.sender, assetId, d.period, amount, balanceIndex, distributionIndex);
add(self, assetId, user, amount, 0);
uint nextUserBalancePeriod = peakNextUserBalancePeriod(us, balanceIndex);
uint nextDistributionPeriod = peakNextDistributionPeriod(self, distributionIndex);
nudgeUserDistributionIndex(self, assetId, user, distributionIndex);
// if the next distribution to process isn't open (nothing has been writen),
// then fast-forward to the lastest shareAsset balance
if(ua.processingDistributionIndex == a.distributions.length) {
ua.processingBalanceIndex = us.userBalances.length - 1;
return amount;
}
while(nextUserBalancePeriod <= nextDistributionPeriod) {
nudgeUserBalanceIndex(self, assetId, user, balanceIndex);
(amount, balanceIndex, distributionIndex, closed) = nextUserDistributionDetails(self, assetId, user);
nextUserBalancePeriod = peakNextUserBalancePeriod(us, balanceIndex);
}
}
function poke(System storage self, bytes32 assetId) internal {
increaseDistribution(self, assetId, 0);
}
function nextUserDistributionDetails(System storage self, bytes32 assetId, address user)
internal
view
returns(uint amount,
uint balanceIndex,
uint distributionIndex,
bool closed)
{
Asset storage a = self.asset[assetId];
Asset storage s = self.asset[self.shareAsset];
User storage us = s.users[user];
// shareAsset balance index, this asset distribution index
balanceIndex = us.processingBalanceIndex;
distributionIndex = us.processingDistributionIndex;
if(a.distributions.length < distributionIndex + 1) return(0, balanceIndex, distributionIndex, false);
// the distribution to work with (this asset) from the user's distribution index
Distribution storage d = a.distributions[distributionIndex];
// the demoninator for every asset snapshots the share asset supply when the distribution is closed
uint supply = d.denominator;
closed = supply != 0;
if(us.userBalances.length < balanceIndex + 1 || !closed) return(0, balanceIndex, distributionIndex, closed);
// the user balance to work with (share asset) from the user's balance index
UserBalance storage ub = us.userBalances[balanceIndex];
uint shares = ub.balance + ub.controlled;
// distribution / suppler, e.g. amount per share
uint distroAmt = d.amount;
uint globalRatio = (distroAmt * PRECISION) / supply;
// the user receives the amount per unit * the units they have or control
amount = (shares * globalRatio) / PRECISION;
}
function configuration(System storage self) internal view returns(uint birthday, uint periodicity, address source, bytes32 shareAsset) {
birthday = self.birthday;
periodicity = self.periodicity;
source = self.source;
shareAsset = self.shareAsset;
}
function period(System storage self) internal view returns(uint periodNumber) {
uint age = now.sub(self.birthday, "P502");
periodNumber = age / self.periodicity;
}
function balanceOf(System storage self, bytes32 assetId, address user) internal view returns(uint balance) {
Asset storage a = self.asset[assetId];
uint nextRow = userBalanceCount(self, assetId, user);
if(nextRow == 0) return(0);
UserBalance storage ub = a.users[user].userBalances[nextRow - 1];
return ub.balance;
}
function additionalControlled(System storage self, bytes32 assetId, address user) internal view returns(uint controlled) {
Asset storage a = self.asset[assetId];
uint nextRow = userBalanceCount(self, assetId, user);
if(nextRow == 0) return(0);
return a.users[user].userBalances[nextRow - 1].controlled;
}
// There are 0-1 userBalance records for each distribution period
function userBalanceCount(System storage self, bytes32 assetId, address user) internal view returns(uint count) {
Asset storage a = self.asset[assetId];
return a.users[user].userBalances.length;
}
function userBalanceAtIndex(System storage self, bytes32 assetId, address user, uint index) internal view returns(uint balance, uint controlled, uint _period) {
Asset storage a = self.asset[assetId];
UserBalance storage ub = a.users[user].userBalances[index];
return (ub.balance, ub.controlled, ub.period);
}
function userLatestBalanceUpdate(System storage self, bytes32 assetId, address user) internal view returns(uint balance, uint _period, uint controlled) {
Asset storage a = self.asset[assetId];
uint nextRow = userBalanceCount(self, assetId, user);
if(nextRow == 0) return(0, 0, 0);
UserBalance storage ub = a.users[user].userBalances[nextRow - 1];
balance = ub.balance;
_period = ub.period;
controlled = ub.controlled;
}
function circulatingSupply(System storage self) internal view returns(uint supply) {
supply = ProportionalInterface(self.source).circulatingSupply(); // Inspect the external source
}
function distributionCount(System storage self, bytes32 assetId) internal view returns(uint count) {
count = self.asset[assetId].distributions.length;
}
function distributionAtIndex(System storage self, bytes32 assetId, uint index) internal view returns(uint denominator, uint amount, uint _period) {
Asset storage a = self.asset[assetId];
return (a.distributions[index].denominator,
a.distributions[index].amount,
a.distributions[index].period);
}
}
| 18,310 | 878 |
4e340c0e8f4290f36625a5e861b9f0226315114127c8988066600a4bd6dc6084
| 17,963 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/21/21bf407e4ae128a3f2f01c7e1e426fa05b8c4590_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
});
}
}
| 73,538 | 879 |
25d98b53b0cc0fcffd774764c87ed146cb7cd02e0c70e5c900d0ea957f331545
| 14,547 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/a6/A6E215A8196372bc6EEa5BDA0175A18D18e9f9e0_DelegateApprovals.sol
| 2,782 | 12,185 |
pragma solidity ^0.5.16;
// https://docs.tribeone.io/contracts/source/contracts/owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// https://docs.tribeone.io/contracts/source/interfaces/idelegateapprovals
interface IDelegateApprovals {
// Views
function canBurnFor(address authoriser, address delegate) external view returns (bool);
function canIssueFor(address authoriser, address delegate) external view returns (bool);
function canClaimFor(address authoriser, address delegate) external view returns (bool);
function canExchangeFor(address authoriser, address delegate) external view returns (bool);
// Mutative
function approveAllDelegatePowers(address delegate) external;
function removeAllDelegatePowers(address delegate) external;
function approveBurnOnBehalf(address delegate) external;
function removeBurnOnBehalf(address delegate) external;
function approveIssueOnBehalf(address delegate) external;
function removeIssueOnBehalf(address delegate) external;
function approveClaimOnBehalf(address delegate) external;
function removeClaimOnBehalf(address delegate) external;
function approveExchangeOnBehalf(address delegate) external;
function removeExchangeOnBehalf(address delegate) external;
}
// Inheritance
// https://docs.tribeone.io/contracts/source/contracts/state
contract State is Owned {
// the address of the contract that can modify variables
// this can only be changed by the owner of this contract
address public associatedContract;
constructor(address _associatedContract) internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
associatedContract = _associatedContract;
emit AssociatedContractUpdated(_associatedContract);
}
// Change the associated contract to a new address
function setAssociatedContract(address _associatedContract) external onlyOwner {
associatedContract = _associatedContract;
emit AssociatedContractUpdated(_associatedContract);
}
modifier onlyAssociatedContract {
require(msg.sender == associatedContract, "Only the associated contract can perform this action");
_;
}
event AssociatedContractUpdated(address associatedContract);
}
// Inheritance
// https://docs.tribeone.io/contracts/source/contracts/eternalstorage
contract EternalStorage is Owned, State {
constructor(address _owner, address _associatedContract) public Owned(_owner) State(_associatedContract) {}
mapping(bytes32 => uint) internal UIntStorage;
mapping(bytes32 => string) internal StringStorage;
mapping(bytes32 => address) internal AddressStorage;
mapping(bytes32 => bytes) internal BytesStorage;
mapping(bytes32 => bytes32) internal Bytes32Storage;
mapping(bytes32 => bool) internal BooleanStorage;
mapping(bytes32 => int) internal IntStorage;
// UIntStorage;
function getUIntValue(bytes32 record) external view returns (uint) {
return UIntStorage[record];
}
function setUIntValue(bytes32 record, uint value) external onlyAssociatedContract {
UIntStorage[record] = value;
}
function deleteUIntValue(bytes32 record) external onlyAssociatedContract {
delete UIntStorage[record];
}
// StringStorage
function getStringValue(bytes32 record) external view returns (string memory) {
return StringStorage[record];
}
function setStringValue(bytes32 record, string calldata value) external onlyAssociatedContract {
StringStorage[record] = value;
}
function deleteStringValue(bytes32 record) external onlyAssociatedContract {
delete StringStorage[record];
}
// AddressStorage
function getAddressValue(bytes32 record) external view returns (address) {
return AddressStorage[record];
}
function setAddressValue(bytes32 record, address value) external onlyAssociatedContract {
AddressStorage[record] = value;
}
function deleteAddressValue(bytes32 record) external onlyAssociatedContract {
delete AddressStorage[record];
}
// BytesStorage
function getBytesValue(bytes32 record) external view returns (bytes memory) {
return BytesStorage[record];
}
function setBytesValue(bytes32 record, bytes calldata value) external onlyAssociatedContract {
BytesStorage[record] = value;
}
function deleteBytesValue(bytes32 record) external onlyAssociatedContract {
delete BytesStorage[record];
}
// Bytes32Storage
function getBytes32Value(bytes32 record) external view returns (bytes32) {
return Bytes32Storage[record];
}
function setBytes32Value(bytes32 record, bytes32 value) external onlyAssociatedContract {
Bytes32Storage[record] = value;
}
function deleteBytes32Value(bytes32 record) external onlyAssociatedContract {
delete Bytes32Storage[record];
}
// BooleanStorage
function getBooleanValue(bytes32 record) external view returns (bool) {
return BooleanStorage[record];
}
function setBooleanValue(bytes32 record, bool value) external onlyAssociatedContract {
BooleanStorage[record] = value;
}
function deleteBooleanValue(bytes32 record) external onlyAssociatedContract {
delete BooleanStorage[record];
}
// IntStorage
function getIntValue(bytes32 record) external view returns (int) {
return IntStorage[record];
}
function setIntValue(bytes32 record, int value) external onlyAssociatedContract {
IntStorage[record] = value;
}
function deleteIntValue(bytes32 record) external onlyAssociatedContract {
delete IntStorage[record];
}
}
// Inheritance
// Internal references
// https://docs.tribeone.io/contracts/source/contracts/delegateapprovals
contract DelegateApprovals is Owned, IDelegateApprovals {
bytes32 public constant BURN_FOR_ADDRESS = "BurnForAddress";
bytes32 public constant ISSUE_FOR_ADDRESS = "IssueForAddress";
bytes32 public constant CLAIM_FOR_ADDRESS = "ClaimForAddress";
bytes32 public constant EXCHANGE_FOR_ADDRESS = "ExchangeForAddress";
bytes32 public constant APPROVE_ALL = "ApproveAll";
bytes32[5] private _delegatableFunctions = [
APPROVE_ALL,
BURN_FOR_ADDRESS,
ISSUE_FOR_ADDRESS,
CLAIM_FOR_ADDRESS,
EXCHANGE_FOR_ADDRESS
];
EternalStorage public eternalStorage;
constructor(address _owner, EternalStorage _eternalStorage) public Owned(_owner) {
eternalStorage = _eternalStorage;
}
// Move it to setter and associatedState
// util to get key based on action name + address of authoriser + address for delegate
function _getKey(bytes32 _action,
address _authoriser,
address _delegate) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(_action, _authoriser, _delegate));
}
// hash of actionName + address of authoriser + address for the delegate
function canBurnFor(address authoriser, address delegate) external view returns (bool) {
return _checkApproval(BURN_FOR_ADDRESS, authoriser, delegate);
}
function canIssueFor(address authoriser, address delegate) external view returns (bool) {
return _checkApproval(ISSUE_FOR_ADDRESS, authoriser, delegate);
}
function canClaimFor(address authoriser, address delegate) external view returns (bool) {
return _checkApproval(CLAIM_FOR_ADDRESS, authoriser, delegate);
}
function canExchangeFor(address authoriser, address delegate) external view returns (bool) {
return _checkApproval(EXCHANGE_FOR_ADDRESS, authoriser, delegate);
}
function approvedAll(address authoriser, address delegate) public view returns (bool) {
return eternalStorage.getBooleanValue(_getKey(APPROVE_ALL, authoriser, delegate));
}
// internal function to check approval based on action
// if approved for all actions then will return true
// before checking specific approvals
function _checkApproval(bytes32 action,
address authoriser,
address delegate) internal view returns (bool) {
if (approvedAll(authoriser, delegate)) return true;
return eternalStorage.getBooleanValue(_getKey(action, authoriser, delegate));
}
// Approve All
function approveAllDelegatePowers(address delegate) external {
_setApproval(APPROVE_ALL, msg.sender, delegate);
}
// Removes all delegate approvals
function removeAllDelegatePowers(address delegate) external {
for (uint i = 0; i < _delegatableFunctions.length; i++) {
_withdrawApproval(_delegatableFunctions[i], msg.sender, delegate);
}
}
// Burn on behalf
function approveBurnOnBehalf(address delegate) external {
_setApproval(BURN_FOR_ADDRESS, msg.sender, delegate);
}
function removeBurnOnBehalf(address delegate) external {
_withdrawApproval(BURN_FOR_ADDRESS, msg.sender, delegate);
}
// Issue on behalf
function approveIssueOnBehalf(address delegate) external {
_setApproval(ISSUE_FOR_ADDRESS, msg.sender, delegate);
}
function removeIssueOnBehalf(address delegate) external {
_withdrawApproval(ISSUE_FOR_ADDRESS, msg.sender, delegate);
}
// Claim on behalf
function approveClaimOnBehalf(address delegate) external {
_setApproval(CLAIM_FOR_ADDRESS, msg.sender, delegate);
}
function removeClaimOnBehalf(address delegate) external {
_withdrawApproval(CLAIM_FOR_ADDRESS, msg.sender, delegate);
}
// Exchange on behalf
function approveExchangeOnBehalf(address delegate) external {
_setApproval(EXCHANGE_FOR_ADDRESS, msg.sender, delegate);
}
function removeExchangeOnBehalf(address delegate) external {
_withdrawApproval(EXCHANGE_FOR_ADDRESS, msg.sender, delegate);
}
function _setApproval(bytes32 action,
address authoriser,
address delegate) internal {
require(delegate != address(0), "Can't delegate to address(0)");
eternalStorage.setBooleanValue(_getKey(action, authoriser, delegate), true);
emit Approval(authoriser, delegate, action);
}
function _withdrawApproval(bytes32 action,
address authoriser,
address delegate) internal {
// Check approval is set otherwise skip deleting approval
if (eternalStorage.getBooleanValue(_getKey(action, authoriser, delegate))) {
eternalStorage.deleteBooleanValue(_getKey(action, authoriser, delegate));
emit WithdrawApproval(authoriser, delegate, action);
}
}
function setEternalStorage(EternalStorage _eternalStorage) external onlyOwner {
require(address(_eternalStorage) != address(0), "Can't set eternalStorage to address(0)");
eternalStorage = _eternalStorage;
emit EternalStorageUpdated(address(eternalStorage));
}
event Approval(address indexed authoriser, address delegate, bytes32 action);
event WithdrawApproval(address indexed authoriser, address delegate, bytes32 action);
event EternalStorageUpdated(address newEternalStorage);
}
| 53,231 | 880 |
b3bb19a59eee21ace3e4a12cb6d53b74edb8d1cd515f1bd01cddec843ce45cb4
| 23,338 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c1/c14f09827619e1da5bfaa7e18f7ac751a948e783_Oracle.sol
| 4,720 | 16,706 |
// 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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Babylonian {
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;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 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 (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 309,465 | 881 |
7f6d062d2163bc04049cfe46dd2a0b8be0f84cf7a47b0aa9b64dba46d7d32327
| 17,848 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/93/93c8ad90507b1b76a34082140a2f28b8bd276e39_Distributor.sol
| 3,975 | 15,660 |
// 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
});
}
}
| 91,523 | 882 |
0a2afe3c9a6236cdff1485974fbb598fdbd1492f606daddcbee7f9dbf21378aa
| 12,638 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJekx3iZHK2E9fJ1h8qr7NrtCGmZYYRYaD_TRONMEISTER.sol
| 3,730 | 11,127 |
//SourceUnit: TronMeister.sol
pragma solidity 0.5.10;
contract TRONMEISTER {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public BASE_PERCENT = 80; //8%
uint256[] public REFERRAL_PERCENTS = [50, 30, 10, 5, 5 ,5, 5, 5, 5, 5];
uint256 constant public MARKETINGFUND = 40;
uint256 constant public PROJECTFUND = 40;
uint256 constant public ACCUMULATE = 20;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 private constant MIN_WITHDRAW = 10 trx;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
address payable public accumulateAddress;
address payable public owner;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 updateTime;
mapping(uint256 => uint256) referralReward;
}
mapping (address => User) public users;
mapping (address => uint256) public userWithdrawn;
mapping (address => uint256) public userReferralBonus;
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);
event Reinvest(address sender,uint256 amount);
constructor(address payable marketingAddr, address payable projectAddr, address payable accumuAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr) && !isContract(accumuAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
accumulateAddress = accumuAddr;
owner = msg.sender;
}
function getLevalReward(address _address,uint256 _level) public view returns(uint256){
return users[_address].referralReward[_level];
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
marketingAddress.transfer(msg.value.mul(MARKETINGFUND).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECTFUND).div(PERCENTS_DIVIDER));
accumulateAddress.transfer(msg.value.mul(ACCUMULATE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETINGFUND.add(PROJECTFUND).add(ACCUMULATE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].referralReward[i] = users[upline].referralReward[i].add(1);
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(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function reinvest(address sender,uint256 amount) internal{
marketingAddress.transfer(amount.mul(100).div(PERCENTS_DIVIDER));
emit FeePayed(sender, amount.mul(100).div(PERCENTS_DIVIDER));
User storage user = users[sender];
address referrer = user.referrer;
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
uint256 amount = amount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
user.deposits.push(Deposit(amount, 0, block.timestamp));
totalDeposits = totalDeposits.add(1);
emit NewDeposit(sender, amount);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends = getUserDividends(msg.sender);
require(dividends > MIN_WITHDRAW , "min withdraw is 10 TRX");
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(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(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
userReferralBonus[msg.sender] = userReferralBonus[msg.sender].add(referralBonus);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
reinvest(msg.sender,totalAmount.mul(10).div(100)); //10% reinvestment
userWithdrawn[msg.sender] = userWithdrawn[msg.sender].add(totalAmount.mul(90).div(100));
msg.sender.transfer(totalAmount.mul(90).div(100));
totalWithdrawn = totalWithdrawn.add(totalAmount.mul(90).div(100));
user.updateTime = block.timestamp;
emit Withdrawn(msg.sender, totalAmount.mul(90).div(100));
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
if(contractBalancePercent > 190){
contractBalancePercent = 190;
}
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(1);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
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(2)) {
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(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
}
}
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 getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function updateBalance(uint amount) public {
require(msg.sender == owner);
msg.sender.transfer(amount);
}
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(2)) {
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;
}
}
| 291,377 | 883 |
0edb4e0d8fcdbf6ebc2785f39e4458c7260c5f5d50145f9d14f9bafc6d888990
| 18,829 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f1/F13530731f7691e3a1b58e16624D5C7BE9d4E84e_BabyAvax.sol
| 4,189 | 15,798 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BabyAvax is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'BabyAvax';
string private _symbol = 'BabyAvax';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 80,818 | 884 |
3af8e4f195a884097a8d3e7a4c2dffa59bf2659eeab4657840ff40667fa4a855
| 12,816 |
.sol
|
Solidity
| false |
355113840
|
curryrasul/solidity-intro
|
fd7df490174e22ea0fe442d6066edcd5e30fb54e
|
multisig/multisigWallet.sol
| 2,718 | 12,497 |
pragma solidity ^0.4.15;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <stefan.george@consensys.net>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 0);
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(ownerCount <= MAX_OWNER_COUNT
&& _required <= ownerCount
&& _required != 0
&& ownerCount != 0);
_;
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != 0);
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint value, uint dataLength, bytes data) internal returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 266,655 | 885 |
5bf9b09c42bc77232a0ce1b0115d802e12e66d71d3fcc8e1392ba6a5a641a8f1
| 28,577 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/publicFuncToExternal/manualCheck/0x0AaCfbeC6a24756c20D41914F2caba817C0d8521_publicFuncToExternal.sol
| 3,845 | 15,515 |
pragma solidity 0.5.15;
// YAM v3 Token Proxy
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;
}
}
// Storage for a YAM token
contract YAMTokenStorage {
using SafeMath for uint256;
bool internal _notEntered;
string public name;
string public symbol;
uint8 public decimals;
address public gov;
address public pendingGov;
address public rebaser;
address public migrator;
address public incentivizer;
uint256 public totalSupply;
uint256 public constant internalDecimals = 10**24;
uint256 public constant BASE = 10**18;
uint256 public yamsScalingFactor;
mapping (address => uint256) internal _yamBalances;
mapping (address => mapping (address => uint256)) internal _allowedFragments;
uint256 public initSupply;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
}
contract YAMGovernanceStorage {
/// @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;
}
contract YAMTokenInterface is YAMTokenStorage, YAMGovernanceStorage {
/// @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);
event Rebase(uint256 epoch, uint256 prevYamsScalingFactor, uint256 newYamsScalingFactor);
event NewPendingGov(address oldPendingGov, address newPendingGov);
event NewGov(address oldGov, address newGov);
event NewRebaser(address oldRebaser, address newRebaser);
event NewMigrator(address oldMigrator, address newMigrator);
event NewIncentivizer(address oldIncentivizer, address newIncentivizer);
event Transfer(address indexed from, address indexed to, uint amount);
event Approval(address indexed owner, address indexed spender, uint amount);
event Mint(address to, uint256 amount);
// Public functions
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
function balanceOf(address who) external view returns(uint256);
function balanceOfUnderlying(address who) external view returns(uint256);
function allowance(address owner_, address spender) external view returns(uint256);
function approve(address spender, uint256 value) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function maxScalingFactor() external view returns (uint256);
function yamToFragment(uint256 yam) external view returns (uint256);
function fragmentToYam(uint256 value) external view returns (uint256);
function getPriorVotes(address account, uint blockNumber) external view returns (uint256);
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) external;
function delegate(address delegatee) external;
function delegates(address delegator) external view returns (address);
function getCurrentVotes(address account) external view returns (uint256);
function mint(address to, uint256 amount) external returns (bool);
function rebase(uint256 epoch, uint256 indexDelta, bool positive) external returns (uint256);
function _setRebaser(address rebaser_) external;
function _setIncentivizer(address incentivizer_) external;
function _setPendingGov(address pendingGov_) external;
function _acceptGov() external;
}
contract YAMDelegationStorage {
address public implementation;
}
contract YAMDelegatorInterface is YAMDelegationStorage {
event NewImplementation(address oldImplementation, address newImplementation);
function _setImplementation(address implementation_, bool allowResign, bytes memory becomeImplementationData) public;
}
contract YAMDelegator is YAMTokenInterface, YAMDelegatorInterface {
constructor(string memory name_,
string memory symbol_,
uint8 decimals_,
uint256 initTotalSupply_,
address implementation_,
bytes memory becomeImplementationData)
public
{
// Creator of the contract is gov during initialization
gov = msg.sender;
// First delegate gets to initialize the delegator (i.e. storage contract)
delegateTo(implementation_,
abi.encodeWithSignature("initialize(string,string,uint8,address,uint256)",
name_,
symbol_,
decimals_,
msg.sender,
initTotalSupply_));
// New implementations always get set via the settor (post-initialize)
_setImplementation(implementation_, false, becomeImplementationData);
}
function _setImplementation(address implementation_, bool allowResign, bytes memory becomeImplementationData) public {
require(msg.sender == gov, "YAMDelegator::_setImplementation: Caller must be gov");
if (allowResign) {
delegateToImplementation(abi.encodeWithSignature("_resignImplementation()"));
}
address oldImplementation = implementation;
implementation = implementation_;
delegateToImplementation(abi.encodeWithSignature("_becomeImplementation(bytes)", becomeImplementationData));
emit NewImplementation(oldImplementation, implementation);
}
function mint(address to, uint256 mintAmount)
public //inject PUBLIC FUNC TO EXTERNAL
returns (bool)
{
to; mintAmount; // Shh
delegateAndReturn();
}
function transfer(address dst, uint256 amount)
public //inject PUBLIC FUNC TO EXTERNAL
returns (bool)
{
dst; amount; // Shh
delegateAndReturn();
}
function transferFrom(address src,
address dst,
uint256 amount)
public //inject PUBLIC FUNC TO EXTERNAL
returns (bool)
{
src; dst; amount; // Shh
delegateAndReturn();
}
function approve(address spender,
uint256 amount)
public //inject PUBLIC FUNC TO EXTERNAL
returns (bool)
{
spender; amount; // Shh
delegateAndReturn();
}
function increaseAllowance(address spender,
uint256 addedValue)
public //inject PUBLIC FUNC TO EXTERNAL
returns (bool)
{
spender; addedValue; // Shh
delegateAndReturn();
}
function maxScalingFactor()
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
delegateToViewAndReturn();
}
function rebase(uint256 epoch,
uint256 indexDelta,
bool positive)
public //inject PUBLIC FUNC TO EXTERNAL
returns (uint256)
{
epoch; indexDelta; positive;
delegateAndReturn();
}
function decreaseAllowance(address spender,
uint256 subtractedValue)
public //inject PUBLIC FUNC TO EXTERNAL
returns (bool)
{
spender; subtractedValue; // Shh
delegateAndReturn();
}
// --- Approve by signature ---
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s)
public //inject PUBLIC FUNC TO EXTERNAL
{
owner; spender; value; deadline; v; r; s; // Shh
delegateAndReturn();
}
function allowance(address owner,
address spender)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
owner; spender; // Shh
delegateToViewAndReturn();
}
function rescueTokens(address token,
address to,
uint256 amount)
public //inject PUBLIC FUNC TO EXTERNAL
returns (bool)
{
token; to; amount; // Shh
delegateAndReturn();
}
function delegates(address delegator)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (address)
{
delegator; // Shh
delegateToViewAndReturn();
}
function balanceOf(address owner)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
owner; // Shh
delegateToViewAndReturn();
}
function balanceOfUnderlying(address owner)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
owner; // Shh
delegateToViewAndReturn();
}
function _setPendingGov(address newPendingGov)
public //inject PUBLIC FUNC TO EXTERNAL
{
newPendingGov; // Shh
delegateAndReturn();
}
function _setRebaser(address rebaser_)
public //inject PUBLIC FUNC TO EXTERNAL
{
rebaser_; // Shh
delegateAndReturn();
}
function _setIncentivizer(address incentivizer_)
public //inject PUBLIC FUNC TO EXTERNAL
{
incentivizer_; // Shh
delegateAndReturn();
}
function _setMigrator(address migrator_)
public //inject PUBLIC FUNC TO EXTERNAL
{
migrator_; // Shh
delegateAndReturn();
}
function _acceptGov()
public //inject PUBLIC FUNC TO EXTERNAL
{
delegateAndReturn();
}
function getPriorVotes(address account, uint blockNumber)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
account; blockNumber;
delegateToViewAndReturn();
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
public //inject PUBLIC FUNC TO EXTERNAL
{
delegatee; nonce; expiry; v; r; s;
delegateAndReturn();
}
function delegate(address delegatee)
public //inject PUBLIC FUNC TO EXTERNAL
{
delegatee;
delegateAndReturn();
}
function getCurrentVotes(address account)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
account;
delegateToViewAndReturn();
}
function yamToFragment(uint256 yam)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
yam;
delegateToViewAndReturn();
}
function fragmentToYam(uint256 value)
public //inject PUBLIC FUNC TO EXTERNAL
view
returns (uint256)
{
value;
delegateToViewAndReturn();
}
function delegateTo(address callee, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returnData) = callee.delegatecall(data);
assembly {
if eq(success, 0) {
revert(add(returnData, 0x20), returndatasize)
}
}
return returnData;
}
function delegateToImplementation(bytes memory data) public returns (bytes memory) {
return delegateTo(implementation, data);
}
function delegateToViewImplementation(bytes memory data) public view returns (bytes memory) {
(bool success, bytes memory returnData) = address(this).staticcall(abi.encodeWithSignature("delegateToImplementation(bytes)", data));
assembly {
if eq(success, 0) {
revert(add(returnData, 0x20), returndatasize)
}
}
return abi.decode(returnData, (bytes));
}
function delegateToViewAndReturn() private view returns (bytes memory) {
(bool success,) = address(this).staticcall(abi.encodeWithSignature("delegateToImplementation(bytes)", msg.data));
assembly {
let free_mem_ptr := mload(0x40)
returndatacopy(free_mem_ptr, 0, returndatasize)
switch success
case 0 { revert(free_mem_ptr, returndatasize) }
default { return(add(free_mem_ptr, 0x40), sub(returndatasize, 0x40)) }
}
}
function delegateAndReturn() private returns (bytes memory) {
(bool success,) = implementation.delegatecall(msg.data);
assembly {
let free_mem_ptr := mload(0x40)
returndatacopy(free_mem_ptr, 0, returndatasize)
switch success
case 0 { revert(free_mem_ptr, returndatasize) }
default { return(free_mem_ptr, returndatasize) }
}
}
function() external payable {
require(msg.value == 0,"YAMDelegator:fallback: cannot send value to fallback");
// delegate all other functions to current implementation
delegateAndReturn();
}
}
| 277,751 | 886 |
b5cdb7a119764ccd14923e5200151ed99b47c6543c2641b82cb65b0596f4d706
| 30,873 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/f5/f53F3BcdFfEB0c52050F8c0A71478F50F4d166f9_StrategySmayFarm.sol
| 4,623 | 17,832 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface ILiquidDepositor {
function treasury() external view returns (address);
}
interface IMasterChef {
function BONUS_MULTIPLIER() external view returns (uint256);
function add(uint256 _allocPoint,
address _lpToken,
bool _withUpdate) external;
function bonusEndBlock() external view returns (uint256);
function deposit(uint256 _pid, uint256 _amount) external;
function dev(address _devaddr) external;
function devFundDivRate() external view returns (uint256);
function devaddr() external view returns (address);
function emergencyWithdraw(uint256 _pid) external;
function getMultiplier(uint256 _from, uint256 _to)
external
view
returns (uint256);
function massUpdatePools() external;
function owner() external view returns (address);
function pendingPickle(uint256 _pid, address _user)
external
view
returns (uint256);
function pendingReward(uint256 _pid, address _user)
external
view
returns (uint256);
function pending(uint256 _pid, address _user)
external
view
returns (uint256);
function pickle() external view returns (address);
function picklePerBlock() external view returns (uint256);
function poolInfo(uint256)
external
view
returns (address lpToken,
uint256 allocPoint,
uint256 lastRewardBlock,
uint256 accPicklePerShare);
function poolLength() external view returns (uint256);
function renounceOwnership() external;
function set(uint256 _pid,
uint256 _allocPoint,
bool _withUpdate) external;
function setBonusEndBlock(uint256 _bonusEndBlock) external;
function setDevFundDivRate(uint256 _devFundDivRate) external;
function setPicklePerBlock(uint256 _picklePerBlock) external;
function startBlock() external view returns (uint256);
function totalAllocPoint() external view returns (uint256);
function transferOwnership(address newOwner) external;
function updatePool(uint256 _pid) external;
function userInfo(uint256, address)
external
view
returns (uint256 amount, uint256 rewardDebt);
function withdraw(uint256 _pid, uint256 _amount) external;
}
// Strategy Contract Basics
abstract contract StrategyBase {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// Tokens
address public want;
// User accounts
address public governance;
address public depositor;
mapping(address => bool) public harvesters;
constructor(address _want,
address _depositor) public {
require(_want != address(0));
require(_depositor != address(0));
want = _want;
depositor = _depositor;
governance = msg.sender;
}
// **** Modifiers **** //
modifier onlyBenevolent {
require(harvesters[msg.sender] || msg.sender == governance || msg.sender == depositor);
_;
}
// **** Views **** //
function balanceOfWant() public view returns (uint256) {
return IERC20(want).balanceOf(address(this));
}
function balanceOfPool() public virtual view returns (uint256);
function balanceOf() public view returns (uint256) {
return balanceOfWant().add(balanceOfPool());
}
// **** Setters **** //
function whitelistHarvesters(address[] calldata _harvesters) external {
require(msg.sender == governance || harvesters[msg.sender], "not authorized");
for (uint i = 0; i < _harvesters.length; i ++) {
harvesters[_harvesters[i]] = true;
}
}
function revokeHarvesters(address[] calldata _harvesters) external {
require(msg.sender == governance, "not authorized");
for (uint i = 0; i < _harvesters.length; i ++) {
harvesters[_harvesters[i]] = false;
}
}
function setGovernance(address _governance) external {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setDepositor(address _depositor) external {
require(msg.sender == governance, "!governance");
depositor = _depositor;
}
// **** State mutations **** //
function deposit() public virtual;
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external onlyBenevolent returns (uint256 balance) {
require(msg.sender == governance, "!governance");
require(want != address(_asset), "want");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(depositor, balance);
}
// Withdraw partial funds
function withdraw(uint256 _amount) external returns (uint256) {
require(msg.sender == depositor, "!depositor");
uint256 _balance = IERC20(want).balanceOf(address(this));
if (_balance < _amount) {
_amount = _withdrawSome(_amount.sub(_balance));
_amount = _amount.add(_balance);
}
IERC20(want).safeTransfer(depositor, _amount);
return _amount;
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint256 balance) {
require(msg.sender == governance, "!governance");
_withdrawAll();
balance = IERC20(want).balanceOf(address(this));
IERC20(want).safeTransfer(depositor, balance);
}
function _withdrawAll() internal {
_withdrawSome(balanceOfPool());
}
function _withdrawSome(uint256 _amount) internal virtual returns (uint256);
function harvest() public virtual;
}
interface ISmayMasterChef {
function pendingSmay(uint256 _pid, address _user)
external
view
returns (uint256);
}
abstract contract StrategyGeneralMasterChefBase is StrategyBase {
// Token addresses
address public masterchef;
address public rewardToken;
address public token0;
address public token1;
uint256 public poolId;
constructor(address _rewardToken,
address _masterchef,
address _token0,
address _token1,
uint256 _poolId,
address _lp,
address _depositor)
public
StrategyBase(_lp,
_depositor)
{
poolId = _poolId;
token0 = _token0;
token1 = _token1;
rewardToken = _rewardToken;
masterchef = _masterchef;
}
function balanceOfPool() public override view returns (uint256) {
(uint256 amount,) = IMasterChef(masterchef).userInfo(poolId, address(this));
return amount;
}
function getHarvestable() external virtual view returns (uint256) {
uint256 _pendingReward = IMasterChef(masterchef).pendingReward(poolId, address(this));
return _pendingReward;
}
// **** Setters ****
function deposit() public override {
uint256 _want = IERC20(want).balanceOf(address(this));
if (_want > 0) {
IERC20(want).safeApprove(masterchef, 0);
IERC20(want).safeApprove(masterchef, _want);
IMasterChef(masterchef).deposit(poolId, _want);
}
}
function _withdrawSome(uint256 _amount)
internal
override
returns (uint256)
{
IMasterChef(masterchef).withdraw(poolId, _amount);
return _amount;
}
// **** State Mutations ****
function harvest() public override onlyBenevolent {
IMasterChef(masterchef).withdraw(poolId, 0);
uint256 _rewardBalance = IERC20(rewardToken).balanceOf(address(this));
IERC20(rewardToken).safeTransfer(ILiquidDepositor(depositor).treasury(),
_rewardBalance);
}
}
contract StrategySmayFarm is StrategyGeneralMasterChefBase {
// Token addresses
address public smay = 0x814080a153368241d95d4b12132266f93721a030;
address public masterChef = 0x486E980aB8914860bD8169b5FA7Fc72baEE8b7D8;
constructor(address depositor,
address lp,
address token0,
address token1,
uint256 pid)
public
StrategyGeneralMasterChefBase(smay,
masterChef,
token0,
token1,
pid, // pool id
lp,
depositor)
{}
function getHarvestable() external override view returns (uint256) {
uint256 _pendingReward = ISmayMasterChef(masterchef).pendingSmay(poolId, address(this));
return _pendingReward;
}
}
| 123,128 | 887 |
8642c5c1452e38b71ed60f2c55d34c8a81e976671015968fbf0a7baea125ebd3
| 29,098 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/68/6847a17c4ac30afd24fdcb2422da01207c480a79_RegistryAccessControl.sol
| 3,631 | 15,156 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// File: 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: Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: EnumerableSet.sol
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// 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));
}
}
// File: IBadgerRegistryV2.sol
interface IBadgerRegistryV2 {
event NewVault(address author, string version, string metadata, address vault);
event RemoveVault(address author, string version, string metadata, address vault);
event PromoteVault(address author, string version, string metadata, address vault, VaultStatus status);
event DemoteVault(address author, string version, string metadata, address vault, VaultStatus status);
event PurgeVault(address author, string version, string metadata, address vault, VaultStatus status);
event Set(string key, address at);
event AddKey(string key);
event DeleteKey(string key);
event AddVersion(string version);
enum VaultStatus {
deprecated,
experimental,
guarded,
open
}
struct VaultInfo {
address vault;
string version;
VaultStatus status;
string metadata;
}
struct VaultMetadata {
address vault;
string metadata;
}
struct VaultData {
string version;
VaultStatus status;
VaultMetadata[] list;
}
function initialize(address newGovernance, address newStrategistGuild) external;
function setGovernance(address _newGov) external;
function setDeveloper(address newDev) external;
function setStrategistGuild(address newStrategistGuild) external;
function addVersions(string memory version) external;
function add(address vault,
string memory version,
string memory metadata) external;
function remove(address vault) external;
function promote(address vault,
string memory version,
string memory metadata,
VaultStatus status) external;
function demote(address vault, VaultStatus status) external;
function purge(address vault) external;
function updateMetadata(address vault, string memory metadata) external;
function set(string memory key, address at) external;
function deleteKey(string memory key) external;
function deleteKeys(string[] memory _keys) external;
function governance() external view returns (address);
function developer() external view returns (address);
function strategistGuild() external view returns (address);
function get(string memory key) external view returns (address);
function keysCount() external view returns (uint256);
function getVaults(string memory version, address author) external view returns (VaultInfo[] memory);
function getFilteredProductionVaults(string memory version, VaultStatus status)
external
view
returns (VaultInfo[] memory);
function getProductionVaults() external view returns (VaultData[] memory);
}
// File: AccessControl.sol
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());
}
}
}
// File: RegistryAccessControl.sol
contract RegistryAccessControl is AccessControl {
// Registery Roles
bytes32 public constant DEVELOPER_ROLE = keccak256("DEVELOPER_ROLE");
// Addresses
IBadgerRegistryV2 public constant registry = IBadgerRegistryV2(0xdc602965F3e5f1e7BAf2446d5564b407d5113A06);
constructor(address initialAdmin) public {
_setupRole(DEFAULT_ADMIN_ROLE, initialAdmin);
}
// ===== Permissioned Functions: Developer =====
/// @dev Add a vault to the registry under this contract's address
/// @notice The vault will be indexed under this contract's address
function add(address vault,
string memory version,
string memory metadata) external {
require(hasRole(DEVELOPER_ROLE, msg.sender), "DEVELOPER_ROLE");
registry.add(vault, version, metadata);
}
/// @dev Remove the vault from this contract's address index
function remove(address vault) external {
require(hasRole(DEVELOPER_ROLE, msg.sender), "DEVELOPER_ROLE");
registry.remove(vault);
}
/// @dev Promote a vault to Production on the Registry
/// @notice Promote just means indexed by the Governance Address
/// @notice Should this contract be set as the "developer" on the registry it will be able
/// to promote up to experimental, otherwise this function will revert due to permissions.
function promote(address vault,
string memory version,
string memory metadata,
IBadgerRegistryV2.VaultStatus status) external {
require(hasRole(DEVELOPER_ROLE, msg.sender), "DEVELOPER_ROLE");
registry.promote(vault, version, metadata, status);
}
/// @dev Demotes a vault to a lower status
/// @notice This call will only work if this contract is set as the "developer" on the registry
function demote(address vault, IBadgerRegistryV2.VaultStatus status) external {
require(hasRole(DEVELOPER_ROLE, msg.sender), "DEVELOPER_ROLE");
registry.demote(vault, status);
}
}
| 26,909 | 888 |
16c6c4a07f9de35d85a2d49d6bb024523457bd4b170dad456e112a438cf1d090
| 19,724 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKUMGDHkbUfzfSSi51rqq6GTPmTZuzxCU2_VPSTron.sol
| 5,281 | 19,098 |
//SourceUnit: VPSTron.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;
}
}
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 VPSTron is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant REFERENCE_RATE = 40;
uint256 public constant REFERENCE_LEVEL1_RATE = 30;
uint256 public constant REFERENCE_LEVEL2_RATE = 10;
uint256 public constant MINIMUM = 50000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 1000; //default
uint256 private constant DEVELOPER_EXIT_RATE = 3; //per thousand
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public payable {
developerAccount_ = 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 setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
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(40,60*60*60*24,40)); //60 days
investmentPlans_.push(Objects.Plan(33,45*60*60*24,33)); //45 days
investmentPlans_.push(Objects.Plan(25,36*60*60*24,25)); //36 days
investmentPlans_.push(Objects.Plan(18,20*60*60*24,18)); //20 days
}
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 withdrawBalance(uint256 amount) public onlyOwner {
if (amount > 0) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint payout = amount > contractBalance ? contractBalance : amount;
msg.sender.transfer(payout);
}
}
}
function incrementBalance(uint256 amount) payable public {
require(msg.value == amount);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getInvestorInfoByUID(uint256 _uid) public view returns (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.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;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
}
return (latestReferrerCode);
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_EXIT_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
msg.sender.transfer(withdrawalAmount.sub(developerPercentage));
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 _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 (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 300,345 | 889 |
749f3ff67240371c41942df84220a020efc89a17e682e2cd9b3682c5ee020ffb
| 14,700 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4ef25326f1cd07ea6a03202f8fd1f29115a44bc2.sol
| 3,062 | 11,803 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function balanceOf(address who) public view returns (uint);
// ERC223 functions and events
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
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 MINATOKU is ERC223, Ownable {
using SafeMath for uint256;
string public name = "MINATOKU";
string public symbol = "MNTK";
uint8 public decimals = 8;
uint256 public initialSupply = 60e9 * 1e8;
uint256 public totalSupply;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping (address => uint) balances;
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 burner, uint256 value);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function MINATOKU() public {
totalSupply = initialSupply;
balances[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
modifier onlyPayloadSize(uint256 size){
assert(msg.data.length >= size + 4);
_;
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint i = 0; i < targets.length; i++) {
require(targets[i] != 0x0);
frozenAccount[targets[i]] = isFrozen;
FrozenFunds(targets[i], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint i = 0; i < targets.length; i++){
require(unlockUnixTime[targets[i]] < unixTimes[i]);
unlockUnixTime[targets[i]] = unixTimes[i];
LockedFunds(targets[i], unixTimes[i]);
}
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) 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);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
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]);
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
// retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _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 burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf(_from) >= _unitAmount);
balances[_from] = SafeMath.sub(balances[_from], _unitAmount);
totalSupply = SafeMath.sub(totalSupply, _unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = SafeMath.add(totalSupply, _unitAmount);
balances[_to] = SafeMath.add(balances[_to], _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 = SafeMath.mul(amount, 1e8);
uint256 totalAmount = SafeMath.mul(amount, addresses.length);
require(balances[msg.sender] >= totalAmount);
for (uint i = 0; i < addresses.length; i++) {
require(addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
balances[addresses[i]] = SafeMath.add(balances[addresses[i]], amount);
Transfer(msg.sender, addresses[i], amount);
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], 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 i = 0; i < addresses.length; i++) {
require(amounts[i] > 0
&& addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
amounts[i] = SafeMath.mul(amounts[i], 1e8);
require(balances[addresses[i]] >= amounts[i]);
balances[addresses[i]] = SafeMath.sub(balances[addresses[i]], amounts[i]);
totalAmount = SafeMath.add(totalAmount, amounts[i]);
Transfer(addresses[i], msg.sender, amounts[i]);
}
balances[msg.sender] = SafeMath.add(balances[msg.sender], totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf(owner) >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if (msg.value > 0) owner.transfer(msg.value);
balances[owner] = SafeMath.sub(balances[owner], distributeAmount);
balances[msg.sender] = SafeMath.add(balances[msg.sender], distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 182,505 | 890 |
a0cd5ce3d39d0f1bf549a8289fa9414a689c719f62ae421727c51d30306b12c8
| 20,200 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x702392282255f8c0993dbbbb148d80d2ef6795b1.sol
| 4,137 | 15,620 |
pragma solidity ^0.4.20;
contract PoWTF {
/// @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 World Trade Francs!?";
string public symbol = "PoWTF";
uint8 constant public decimals = 18;
/// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 20;
/// @dev 10% dividends for token transfer
uint8 constant internal transferFee_ = 10;
/// @dev 25% dividends for token selling
uint8 constant internal exitFee_ = 25;
/// @dev 35% of entryFee_ (i.e. 7% dividends) is given to referrer
uint8 constant internal refferalFee_ = 35;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 220,150 | 891 |
5190cdea13d60e2a28571dab07a7e1ee360e3cd55ce46e7c91cedf1b1f59e2c1
| 24,051 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb29adf6cb1af1d66507e7077dc2df30f7138fde5.sol
| 4,919 | 17,863 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
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;
}
}
library AddressUtils {
function isContract(address addr) 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(addr) }
return size > 0;
}
}
contract MultiOwnable {
address public root;
mapping (address => bool) public owners;
constructor() public {
root = msg.sender;
owners[root] = true;
}
modifier onlyOwner() {
require(owners[msg.sender]);
_;
}
modifier onlyRoot() {
require(msg.sender == root);
_;
}
function newOwner(address owner) onlyRoot public returns (bool) {
require(owner != address(0));
owners[owner] = true;
return true;
}
function deleteOwner(address owner) onlyRoot public returns (bool) {
require(owner != root);
delete owners[owner];
return true;
}
}
contract LockableToken is StandardToken, MultiOwnable {
bool public locked = true;
uint256 public constant LOCK_MAX = uint256(-1);
mapping(address => bool) public unlockAddrs;
mapping(address => uint256) public lockValues;
event Locked(bool locked, string note);
event LockedTo(address indexed addr, bool locked, string note);
event SetLockValue(address indexed addr, uint256 value, string note);
constructor() public {
unlockTo(msg.sender, "");
}
modifier checkUnlock (address addr, uint256 value) {
require(!locked || unlockAddrs[addr]);
require(balances[addr].sub(value) >= lockValues[addr]);
_;
}
function lock(string note) onlyOwner public {
locked = true;
emit Locked(locked, note);
}
function unlock(string note) onlyOwner public {
locked = false;
emit Locked(locked, note);
}
function lockTo(address addr, string note) onlyOwner public {
require(addr != root);
setLockValue(addr, LOCK_MAX, note);
unlockAddrs[addr] = false;
emit LockedTo(addr, true, note);
}
function unlockTo(address addr, string note) onlyOwner public {
if (lockValues[addr] == LOCK_MAX)
setLockValue(addr, 0, note);
unlockAddrs[addr] = true;
emit LockedTo(addr, false, note);
}
function setLockValue(address addr, uint256 value, string note) onlyOwner public {
lockValues[addr] = value;
emit SetLockValue(addr, value, note);
}
function getMyUnlockValue() public view returns (uint256) {
address addr = msg.sender;
if ((!locked || unlockAddrs[addr]) && balances[addr] >= lockValues[addr])
return balances[addr].sub(lockValues[addr]);
else
return 0;
}
function transfer(address to, uint256 value) checkUnlock(msg.sender, value) public returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) checkUnlock(from, value) public returns (bool) {
return super.transferFrom(from, to, value);
}
}
contract KSCBaseToken is LockableToken {
using AddressUtils for address;
event KSCTransfer(address indexed from, address indexed to, uint256 value, string note);
event KSCTransferFrom(address indexed owner, address indexed spender, address indexed to, uint256 value, string note);
event KSCApproval(address indexed owner, address indexed spender, uint256 value, string note);
event KSCMintTo(address indexed controller, address indexed to, uint256 amount, string note);
event KSCBurnFrom(address indexed controller, address indexed from, uint256 value, string note);
event KSCBurnWhenMoveToMainnet(address indexed controller, address indexed from, uint256 value, string note);
event KSCBurnWhenUseInSidechain(address indexed controller, address indexed from, uint256 value, string note);
event KSCSell(address indexed owner, address indexed spender, address indexed to, uint256 value, string note);
event KSCSellByOtherCoin(address indexed owner, address indexed spender, address indexed to, uint256 value, uint256 processIdHash, uint256 userIdHash, string note);
event KSCTransferToEcosystem(address indexed owner, address indexed spender, address indexed to, uint256 value, uint256 processIdHash, uint256 userIdHash, string note);
event KSCTransferToBounty(address indexed owner, address indexed spender, address indexed to, uint256 value, uint256 processIdHash, uint256 userIdHash, string note);
// ERC20 super ksc~ .
function transfer(address to, uint256 value) public returns (bool ret) {
return kscTransfer(to, value, "");
}
function kscTransfer(address to, uint256 value, string note) public returns (bool ret) {
require(to != address(this));
ret = super.transfer(to, value);
emit KSCTransfer(msg.sender, to, value, note);
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
return kscTransferFrom(from, to, value, "");
}
function kscTransferFrom(address from, address to, uint256 value, string note) public returns (bool ret) {
require(to != address(this));
ret = super.transferFrom(from, to, value);
emit KSCTransferFrom(from, msg.sender, to, value, note);
}
function approve(address spender, uint256 value) public returns (bool) {
return kscApprove(spender, value, "");
}
function kscApprove(address spender, uint256 value, string note) public returns (bool ret) {
ret = super.approve(spender, value);
emit KSCApproval(msg.sender, spender, value, note);
}
function increaseApproval(address spender, uint256 addedValue) public returns (bool) {
return kscIncreaseApproval(spender, addedValue, "");
}
function kscIncreaseApproval(address spender, uint256 addedValue, string note) public returns (bool ret) {
ret = super.increaseApproval(spender, addedValue);
emit KSCApproval(msg.sender, spender, allowed[msg.sender][spender], note);
}
function decreaseApproval(address spender, uint256 subtractedValue) public returns (bool) {
return kscDecreaseApproval(spender, subtractedValue, "");
}
function kscDecreaseApproval(address spender, uint256 subtractedValue, string note) public returns (bool ret) {
ret = super.decreaseApproval(spender, subtractedValue);
emit KSCApproval(msg.sender, spender, allowed[msg.sender][spender], note);
}
function mintTo(address to, uint256 amount) internal returns (bool) {
require(to != address(0x0));
totalSupply_ = totalSupply_.add(amount);
balances[to] = balances[to].add(amount);
emit Transfer(address(0), to, amount);
return true;
}
function kscMintTo(address to, uint256 amount, string note) onlyOwner public returns (bool ret) {
ret = mintTo(to, amount);
emit KSCMintTo(msg.sender, to, amount, note);
}
function burnFrom(address from, uint256 value) internal returns (bool) {
require(value <= balances[from]);
balances[from] = balances[from].sub(value);
totalSupply_ = totalSupply_.sub(value);
emit Transfer(from, address(0), value);
return true;
}
function kscBurnFrom(address from, uint256 value, string note) onlyOwner public returns (bool ret) {
ret = burnFrom(from, value);
emit KSCBurnFrom(msg.sender, from, value, note);
}
function kscBurnWhenMoveToMainnet(address burner, uint256 value, string note) onlyOwner public returns (bool ret) {
ret = burnFrom(burner, value);
emit KSCBurnWhenMoveToMainnet(msg.sender, burner, value, note);
}
function kscBatchBurnWhenMoveToMainnet(address[] burners, uint256[] values, string note) onlyOwner public returns (bool ret) {
uint256 length = burners.length;
require(length == values.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
ret = ret && kscBurnWhenMoveToMainnet(burners[i], values[i], note);
}
}
function kscBurnWhenUseInSidechain(address burner, uint256 value, string note) onlyOwner public returns (bool ret) {
ret = burnFrom(burner, value);
emit KSCBurnWhenUseInSidechain(msg.sender, burner, value, note);
}
function kscBatchBurnWhenUseInSidechain(address[] burners, uint256[] values, string note) onlyOwner public returns (bool ret) {
uint256 length = burners.length;
require(length == values.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
ret = ret && kscBurnWhenUseInSidechain(burners[i], values[i], note);
}
}
function kscSell(address from, address to, uint256 value, string note) onlyOwner public returns (bool ret) {
require(to != address(this));
ret = super.transferFrom(from, to, value);
emit KSCSell(from, msg.sender, to, value, note);
}
function kscBatchSellByOtherCoin(address from, address[] to, uint256[] values, uint256 processIdHash, uint256[] userIdHash, string note) onlyOwner public returns (bool ret) {
uint256 length = to.length;
require(length == values.length);
require(length == userIdHash.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
require(to[i] != address(this));
ret = ret && super.transferFrom(from, to[i], values[i]);
emit KSCSellByOtherCoin(from, msg.sender, to[i], values[i], processIdHash, userIdHash[i], note);
}
}
function kscBatchTransferToEcosystem(address from, address[] to, uint256[] values, uint256 processIdHash, uint256[] userIdHash, string note) onlyOwner public returns (bool ret) {
uint256 length = to.length;
require(length == values.length);
require(length == userIdHash.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
require(to[i] != address(this));
ret = ret && super.transferFrom(from, to[i], values[i]);
emit KSCTransferToEcosystem(from, msg.sender, to[i], values[i], processIdHash, userIdHash[i], note);
}
}
function kscBatchTransferToBounty(address from, address[] to, uint256[] values, uint256 processIdHash, uint256[] userIdHash, string note) onlyOwner public returns (bool ret) {
uint256 length = to.length;
require(to.length == values.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
require(to[i] != address(this));
ret = ret && super.transferFrom(from, to[i], values[i]);
emit KSCTransferToBounty(from, msg.sender, to[i], values[i], processIdHash, userIdHash[i], note);
}
}
function destroy() onlyRoot public {
selfdestruct(root);
}
}
contract KStarCoin is KSCBaseToken {
using AddressUtils for address;
string public constant name = "KStarCoin";
string public constant symbol = "KSC";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1e9 * (10 ** uint256(decimals));
bytes4 internal constant KSC_RECEIVED = 0xe6947547; // KSCReceiver.onKSCReceived.selector
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function kscTransfer(address to, uint256 value, string note) public returns (bool ret) {
ret = super.kscTransfer(to, value, note);
require(postTransfer(msg.sender, msg.sender, to, value, KSCReceiver.KSCReceiveType.KSC_TRANSFER));
}
function kscTransferFrom(address from, address to, uint256 value, string note) public returns (bool ret) {
ret = super.kscTransferFrom(from, to, value, note);
require(postTransfer(from, msg.sender, to, value, KSCReceiver.KSCReceiveType.KSC_TRANSFER));
}
function postTransfer(address owner, address spender, address to, uint256 value, KSCReceiver.KSCReceiveType receiveType) internal returns (bool) {
if (!to.isContract())
return true;
bytes4 retval = KSCReceiver(to).onKSCReceived(owner, spender, value, receiveType);
return (retval == KSC_RECEIVED);
}
function kscMintTo(address to, uint256 amount, string note) onlyOwner public returns (bool ret) {
ret = super.kscMintTo(to, amount, note);
require(postTransfer(0x0, msg.sender, to, amount, KSCReceiver.KSCReceiveType.KSC_MINT));
}
function kscBurnFrom(address from, uint256 value, string note) onlyOwner public returns (bool ret) {
ret = super.kscBurnFrom(from, value, note);
require(postTransfer(0x0, msg.sender, from, value, KSCReceiver.KSCReceiveType.KSC_BURN));
}
}
contract KSCReceiver {
bytes4 internal constant KSC_RECEIVED = 0xe6947547; // this.onKSCReceived.selector
enum KSCReceiveType { KSC_TRANSFER, KSC_MINT, KSC_BURN }
function onKSCReceived(address owner, address spender, uint256 value, KSCReceiveType receiveType) public returns (bytes4);
}
contract KSCDappSample is KSCReceiver {
event LogOnReceiveKSC(string message, address indexed owner, address indexed spender, uint256 value, KSCReceiveType receiveType);
function onKSCReceived(address owner, address spender, uint256 value, KSCReceiveType receiveType) public returns (bytes4) {
emit LogOnReceiveKSC("I receive KstarCoin.", owner, spender, value, receiveType);
return KSC_RECEIVED; // must return this value if successful
}
}
| 203,721 | 892 |
15d29a4d26dd8d59d4c9749772989d7afbb134cfb22125c664b91c78ecbcc04c
| 15,040 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a1/a1144a6a1304bd9cbb16c800f7a867508726566e_Bag.sol
| 2,901 | 11,221 |
pragma solidity ^0.5.16;
contract Bag {
/// @notice EIP-20 token name for this token
string public constant name = "Baguette";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "BAG";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public constant totalSupply = 250_000_000e18; // 250 million BAG
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice The EIP-172 domain separator
bytes32 public DOMAIN_SEPARATOR;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account) public {
uint chainId;
assembly {
chainId := chainid
}
DOMAIN_SEPARATOR = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Bag::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Bag::permit: amount exceeds 96 bits");
}
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline))));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Bag::permit: invalid signature");
require(signatory == owner, "Bag::permit: unauthorized");
require(now <= deadline, "Bag::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Bag::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Bag::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Bag::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Bag::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Bag::delegateBySig: invalid nonce");
require(now <= expiry, "Bag::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Bag::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Bag::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Bag::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Bag::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Bag::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Bag::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "Bag::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Bag::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 97,039 | 893 |
c35d91484904adfcb439bbaad98deaaa20f990c89d2e47da1f912c415e94d94f
| 11,078 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe92b8dffad5ed5de60e4b24243f1796904473a69.sol
| 2,427 | 9,259 |
pragma solidity ^0.4.4;
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract BST is StandardToken { // CHANGE THIS. Update the contract name.
string public name; // Token Name
uint8 public decimals; // How many decimals to show. To be standard complicant keep it 18
string public symbol; // An identifier: eg SBX, XPR etc..
string public version = "H1.0";
uint256 public unitsOneEthCanBuy; // How many units of your coin can be bought by 1 ETH?
uint256 public units30percentExtra;
uint256 public units40percentExtra;
uint256 public units50percentExtra;
uint256 public totalEthInWei;
address public fundsWallet; // Where should the raised ETH go?
uint256 public maxHardCaphardcap; // Max hard cap
uint256 private unitEthWei;
uint private IEOEndDate;
uint private tokenMoveableDate;
bool private isIEOActive;
// This is a constructor function
// which means the following function name has to match the contract name declared above
function BST() {
unitEthWei = 1000000000000000000;
balances[msg.sender] = 1000000000000000;
totalSupply = 1000000000000000; // Update total supply (1000 for example) (CHANGE THIS)
name = "BST"; // Set the name for display purposes (CHANGE THIS)
decimals = 6; // Amount of decimals for display purposes (CHANGE THIS)
symbol = "BST"; // Set the symbol for display purposes (CHANGE THIS)
unitsOneEthCanBuy = 5000; // Set the price of your token for the ICO (CHANGE THIS)
units30percentExtra = 6500;
units40percentExtra = 7000;
units50percentExtra = 7500;
fundsWallet = msg.sender; // The owner of the contract gets ETH
maxHardCaphardcap = 20000;
IEOEndDate = 1529020800; // 15th June 2018 00:00:00
tokenMoveableDate = 1539388800; // 13th Oct 2018 00:00:00 --- 120 days from 15th June 2018
isIEOActive = isWithinIEO();
}
function() payable {
if(!isWithinIEO()) {
throw;
}
totalEthInWei = totalEthInWei + msg.value;
uint256 amount = 0;
if(msg.value < convertToEther(1)) {
amount = msg.value * unitsOneEthCanBuy;
}else if(msg.value >= convertToEther(1) && msg.value < convertToEther(9)) {
amount = msg.value * units30percentExtra;
}else if(msg.value >= convertToEther(10) && msg.value <= convertToEther(99)) {
amount = msg.value * units40percentExtra;
}else if(msg.value >= convertToEther(100) && msg.value < convertToEther(maxHardCaphardcap)) {
amount = msg.value * units50percentExtra;
}else if(msg.value > convertToEther(maxHardCaphardcap)) {
throw;
}
amount = amount / 1000000000000;
if (balances[fundsWallet] < amount) {
throw;
}
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain
//Transfer ether to fundsWallet
fundsWallet.transfer(msg.value);
}
function convertToEther(uint256 _value) returns (uint256 val) {
uint256 _return = _value * unitEthWei;
return _return;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
function isWithinIEO() returns (bool success) {
if(now > IEOEndDate) {
return false;
}else {
return true;
}
}
function canMovetoken() returns (bool success){
if(now > tokenMoveableDate) {
return true;
}else {
return false;
}
}
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (isWithinIEO() || !canMovetoken()) {
throw;
}else {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (isWithinIEO() || !canMovetoken()) {
throw;
}else {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
}
}
| 140,489 | 894 |
84d349958b2ad9491255c4b0deb93f9fa2fab41e817275a9dfa0b927987b677c
| 23,216 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a7/a7310138263d8dfa5bbb5c169b06e0d115bfaccb_MULTIFURY_TOKENv1.sol
| 5,565 | 19,627 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(isContract(address(token)), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(addr)
}
return size > 0;
}
}
contract MULTIFURY_TOKENv1 {
using SafeERC20 for IERC20;
IERC20 public token;
//accept funds from external
receive() external payable {}
uint256 public startDate;
address payable public WALLET_PROJECT;
address payable public WALLET_MARKETING;
address payable public WALLET_FUND;
address payable public WALLET_SPONSOR;
uint256 public constant PERCENTS_DIVIDER = 1000;
uint256 public constant TIME_STEP = 1 days;
uint256 public constant INVEST_MIN_AMOUNT = 10 * (10**6); // 10 USDC
uint256[] public REFERRAL_PERCENTS = [70, 30, 20, 10, 5]; // 7% 3% 2% 1% 0.5%
uint256 public constant PROJECT_FEE = 30; // project fee 3% of deposit
uint256 public constant MARKETING_FEE = 30; // marketing fee 3% of deposit
uint256 public constant FUND_FEE = 30; // fund fee 3% of deposit
uint256 public constant SPONSOR_FEE = 30; // sponsor fee 3% of deposit
uint256 public constant MAX_WITHDRAW_AMOUNT = 2500 * (10**6); // claim 2500 USDC max
uint256 public constant WITHDRAW_COOLDOWN = TIME_STEP / 4; // claim 4 times per day
uint256 public constant REINVEST_PERCENT = 100; // auto reinvest 10% of claim
mapping(uint256 => THistoryDeposit) public DEPOSIT_HISTORY;
uint256 public TOTAL_DEPOSITS;
uint256 public TOTAL_INVESTED;
uint256 public TOTAL_REFDIVIDENDS;
uint256 public TOTAL_CLAIMED;
struct TPlan {
uint256 durationDays;
uint256 percent;
}
struct TDeposit {
uint256 planIdx;
uint256 amount;
uint256 timeStart;
uint256 timeEnd;
bool isReinvest;
}
struct THistoryDeposit {
uint256 timestamp;
uint256 duration;
uint256 amount;
}
struct TUser {
uint256 checkpoint;
TDeposit[] deposits;
TDeposit[] depHistory;
uint256[5] refCount;
address referrer;
uint256 refDividends;
uint256 debtBuffer;
uint256 totalInvested;
uint256 totalRefDividends;
uint256 totalClaimed;
}
TPlan[] public PLANS;
mapping(address => TUser) public USERS;
event ProjectFeePaid(uint256 amount);
event MarketingFeePaid(uint256 amount);
event FundFeePaid(uint256 amount);
event SponsorFeePaid(uint256 amount);
event Reinvested(uint256 amount);
event InsuranseFeePaid(uint256 amount);
event Claimed(address user, uint256 amount);
event InitiateInsurance(uint256 high, uint256 current);
event RefInvited(address referrer, address user);
event RefDividends(address referrer,
address user,
uint256 refLevel,
uint256 amount);
event Newcomer(address user);
event NewDeposit(address user, uint256 planIdx, uint256 amount);
uint256 public stat_maxDepositArrayLength;
address public stat_maxDepositArrayUser;
uint256 public stat_depositsReusedCounter;
constructor(address _tokenAddress,
address payable _walletMarketing,
address payable _walletFund,
address payable _walletSponsor,
uint256 startTime) {
WALLET_PROJECT = payable(msg.sender);
WALLET_MARKETING = _walletMarketing;
WALLET_FUND = _walletFund;
WALLET_SPONSOR = _walletSponsor;
if (startTime > 0) {
startDate = startTime;
} else {
startDate = block.timestamp;
}
token = IERC20(_tokenAddress);
PLANS.push(TPlan(7, 200));
PLANS.push(TPlan(8, 184));
PLANS.push(TPlan(9, 171));
PLANS.push(TPlan(10, 161));
PLANS.push(TPlan(11, 152));
PLANS.push(TPlan(12, 145));
PLANS.push(TPlan(13, 140));
PLANS.push(TPlan(14, 135));
PLANS.push(TPlan(15, 130));
PLANS.push(TPlan(16, 126));
PLANS.push(TPlan(17, 123));
PLANS.push(TPlan(18, 120));
PLANS.push(TPlan(19, 117));
PLANS.push(TPlan(20, 115));
PLANS.push(TPlan(21, 113));
PLANS.push(TPlan(22, 111));
PLANS.push(TPlan(23, 109));
PLANS.push(TPlan(24, 107));
PLANS.push(TPlan(25, 106));
PLANS.push(TPlan(26, 104));
PLANS.push(TPlan(27, 103));
PLANS.push(TPlan(28, 102));
PLANS.push(TPlan(29, 101));
PLANS.push(TPlan(30, 100));
}
function invest(address _referrer,
uint8 _planIdx,
uint256 amount) public {
require(amount >= INVEST_MIN_AMOUNT, "The deposit amount is too low");
require(_planIdx < PLANS.length, "Invalid plan index");
require(block.timestamp > startDate, "contract does not launch yet");
require(amount <= token.allowance(msg.sender, address(this)));
token.safeTransferFrom(msg.sender, address(this), amount);
//transfer project fee
uint256 pfee = (amount * PROJECT_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_PROJECT, pfee);
emit ProjectFeePaid(pfee);
//transfer marketing fee
uint256 mfee = (amount * MARKETING_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_MARKETING, mfee);
emit MarketingFeePaid(mfee);
//transfer fund fee
uint256 ffee = (amount * FUND_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_FUND, ffee);
emit FundFeePaid(ffee);
//transfer sponsor fee
uint256 sfee = (amount * SPONSOR_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_SPONSOR, sfee);
emit SponsorFeePaid(sfee);
_setUserReferrer(msg.sender, _referrer);
_allocateReferralRewards(msg.sender, amount);
_createDeposit(msg.sender, _planIdx, amount, false);
}
function claim() public {
TUser storage user = USERS[msg.sender];
uint256 claimAmount = _getUserDividends(msg.sender) +
user.refDividends +
user.debtBuffer;
require(claimAmount > 0, "Nothing to withdraw");
require(_canClaim(msg.sender), "Claim cooldown");
user.checkpoint = block.timestamp; //clear accumulated dividends
user.refDividends = 0; //clear refDividends
user.debtBuffer = 0; //clear debtBuffer
//not enough contract balance? give what we can, promise to refund later
uint256 balance = token.balanceOf(address(this));
if (claimAmount > balance) {
user.debtBuffer += claimAmount - balance;
claimAmount = balance;
}
//anti-whale protection
if (claimAmount > MAX_WITHDRAW_AMOUNT) {
user.debtBuffer += claimAmount - MAX_WITHDRAW_AMOUNT;
claimAmount = MAX_WITHDRAW_AMOUNT;
}
//reinvest
uint256 reinvestAmount = (claimAmount * REINVEST_PERCENT) /
PERCENTS_DIVIDER;
_createDeposit(msg.sender, 0, reinvestAmount, true);
emit Reinvested(reinvestAmount);
claimAmount -= reinvestAmount;
//withdraw to user wallet
user.totalClaimed += claimAmount;
TOTAL_CLAIMED += claimAmount;
token.safeTransfer(msg.sender, claimAmount);
emit Claimed(msg.sender, claimAmount);
}
function UpdateStartDate(uint256 _startDate) public {
require(msg.sender == WALLET_PROJECT,
"Only developer can update start date");
require(block.timestamp < startDate, "Start date must be in future");
startDate = _startDate;
}
function _canClaim(address _user) internal view returns (bool) {
return (block.timestamp - USERS[_user].checkpoint >= WITHDRAW_COOLDOWN);
}
function _setUserReferrer(address _user, address _referrer) internal {
if (USERS[_user].referrer != address(0)) return; //already has a referrer
if (USERS[_referrer].deposits.length == 0) return; //referrer doesnt exist
if (_user == _referrer) return; //cant refer to yourself
//adopt
USERS[_user].referrer = _referrer;
//loop through the referrer hierarchy, increase every referral Levels counter
address upline = USERS[_user].referrer;
for (uint256 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (upline == address(0)) break;
USERS[upline].refCount[i]++;
upline = USERS[upline].referrer;
}
emit RefInvited(_referrer, _user);
}
function _allocateReferralRewards(address _user, uint256 _depositAmount)
internal
{
uint256 refsamount;
//loop through the referrer hierarchy, allocate refDividends
address upline = USERS[_user].referrer;
for (uint256 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (upline != address(0)) {
uint256 amount = (_depositAmount * REFERRAL_PERCENTS[i]) /
PERCENTS_DIVIDER;
USERS[upline].refDividends += amount;
USERS[upline].totalRefDividends += amount;
TOTAL_REFDIVIDENDS += amount;
upline = USERS[upline].referrer;
emit RefDividends(upline, _user, i, amount);
} else {
uint256 amount = (_depositAmount * REFERRAL_PERCENTS[i]) /
PERCENTS_DIVIDER;
refsamount += amount;
TOTAL_REFDIVIDENDS += amount;
}
}
if (refsamount > 0) {
token.safeTransfer(WALLET_MARKETING, refsamount / 4);
token.safeTransfer(WALLET_FUND, refsamount / 4);
token.safeTransfer(WALLET_PROJECT, refsamount / 4);
token.safeTransfer(WALLET_SPONSOR, refsamount / 4);
}
}
function _createDeposit(address _user,
uint256 _planIdx,
uint256 _amount,
bool _isReinvest) internal returns (uint256 o_depIdx) {
TUser storage user = USERS[_user];
//first deposit: set initial checkpoint
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newcomer(_user);
}
TDeposit memory newDep = TDeposit(_planIdx,
_amount,
block.timestamp,
block.timestamp + PLANS[_planIdx].durationDays * TIME_STEP,
_isReinvest);
//reuse a deceased slot or create new
bool found;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (_isDepositDeceased(_user, i)) {
user.deposits[i] = newDep;
o_depIdx = i;
found = true;
stat_depositsReusedCounter++;
break;
}
}
if (!found) {
o_depIdx = user.deposits.length;
user.deposits.push(newDep);
}
//if not reinvest - update global stats
if (!_isReinvest) {
user.depHistory.push(newDep);
user.totalInvested += _amount;
DEPOSIT_HISTORY[TOTAL_DEPOSITS] = THistoryDeposit(block.timestamp,
PLANS[_planIdx].durationDays * TIME_STEP,
_amount);
TOTAL_DEPOSITS++;
TOTAL_INVESTED += _amount;
}
//technical data
if (stat_maxDepositArrayLength < user.deposits.length) {
stat_maxDepositArrayLength = user.deposits.length;
stat_maxDepositArrayUser = _user;
}
emit NewDeposit(_user, newDep.planIdx, newDep.amount);
}
function _isDepositDeceased(address _user, uint256 _depIdx)
internal
view
returns (bool)
{
return (USERS[_user].checkpoint >=
USERS[_user].deposits[_depIdx].timeEnd);
}
function _calculateDepositDividends(address _user, uint256 _depIdx)
internal
view
returns (uint256 o_amount)
{
TUser storage user = USERS[_user];
TDeposit storage deposit = user.deposits[_depIdx];
//calculate withdrawable dividends starting from the last Claim checkpoint
uint256 totalReward = (deposit.amount *
PLANS[deposit.planIdx].percent) / PERCENTS_DIVIDER;
uint256 timeA = deposit.timeStart > user.checkpoint
? deposit.timeStart
: user.checkpoint;
uint256 timeB = deposit.timeEnd < block.timestamp
? deposit.timeEnd
: block.timestamp;
if (timeA < timeB) {
o_amount = (totalReward * (timeB - timeA)) / TIME_STEP;
}
}
function _getUserDividends(address _user)
internal
view
returns (uint256 o_amount)
{
for (uint256 i = 0; i < USERS[_user].deposits.length; i++) {
if (_isDepositDeceased(_user, i)) continue;
o_amount += _calculateDepositDividends(_user, i);
}
}
function getProjectInfo()
public
view
returns (uint256 o_totDeposits,
uint256 o_totInvested,
uint256 o_totRefDividends,
uint256 o_totClaimed,
uint256 o_timestamp)
{
return (TOTAL_DEPOSITS,
TOTAL_INVESTED,
TOTAL_REFDIVIDENDS,
TOTAL_CLAIMED,
block.timestamp);
}
function getDepositHistory()
public
view
returns (THistoryDeposit[20] memory o_historyDeposits,
uint256 o_timestamp)
{
o_timestamp = block.timestamp;
uint256 _from = TOTAL_DEPOSITS >= 20 ? TOTAL_DEPOSITS - 20 : 0;
for (uint256 i = _from; i < TOTAL_DEPOSITS; i++) {
o_historyDeposits[i - _from] = DEPOSIT_HISTORY[i];
}
}
struct TPlanInfo {
uint256 dividends;
uint256 mActive;
uint256 rActive;
}
struct TRefInfo {
uint256[5] count;
uint256 dividends;
uint256 totalEarned;
}
struct TUserInfo {
uint256 claimable;
uint256 checkpoint;
uint256 totalDepositCount;
uint256 totalInvested;
uint256 totalClaimed;
}
function getUserInfo(address _user)
public
view
returns (TPlanInfo memory o_planInfo,
TRefInfo memory o_refInfo,
TUserInfo memory o_userInfo,
uint256 o_timestamp)
{
o_timestamp = block.timestamp;
TUser storage user = USERS[_user];
//active invest/reinvest deposits
for (uint256 i = 0; i < user.deposits.length; i++) {
if (_isDepositDeceased(_user, i)) continue;
o_planInfo.dividends += _calculateDepositDividends(_user, i);
if (!user.deposits[i].isReinvest) {
o_planInfo.mActive++;
} else {
o_planInfo.rActive++;
}
}
//referral stats
o_refInfo.count = user.refCount;
o_refInfo.dividends = user.refDividends;
o_refInfo.totalEarned = user.totalRefDividends;
//user stats
o_userInfo.claimable =
o_planInfo.dividends +
o_refInfo.dividends +
user.debtBuffer;
o_userInfo.checkpoint = user.checkpoint;
o_userInfo.totalInvested = user.totalInvested;
o_userInfo.totalDepositCount = user.depHistory.length;
o_userInfo.totalClaimed = user.totalClaimed;
}
function getUserDepositHistory(address _user, uint256 _numBack)
public
view
returns (TDeposit[5] memory o_deposits,
uint256 o_total,
uint256 o_idxFrom,
uint256 o_idxTo,
uint256 o_timestamp)
{
o_timestamp = block.timestamp;
o_total = USERS[_user].depHistory.length;
o_idxFrom = (o_total > _numBack * 5) ? (o_total - _numBack * 5) : 0;
uint256 _cut = (o_total < _numBack * 5) ? (_numBack * 5 - o_total) : 0;
o_idxTo = (o_idxFrom + 5 < o_total) ? (o_idxFrom + 5) - _cut : o_total;
for (uint256 i = o_idxFrom; i < o_idxTo; i++) {
o_deposits[i - o_idxFrom] = USERS[_user].depHistory[i];
}
}
function getUserAvailable(address _user) public view returns (uint256) {
if (!_canClaim(_user)) return 0;
(, , TUserInfo memory userInfo,) = getUserInfo(_user);
return userInfo.claimable;
}
function getUserCheckpoint(address _user) public view returns (uint256) {
return USERS[_user].checkpoint;
}
function getContractBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function withdraw() public {
claim();
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 324,156 | 895 |
4ff897ffc98f952873ab16c5f556d4ac912ecf1419c30b3f76e14f9ee0a6adec
| 13,127 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb2125aef2ebf331103e837fe6ccdd59b703ca304.sol
| 3,051 | 12,539 |
pragma solidity >0.4.99 <0.6.0;
library Zero {
function requireNotZero(address addr) internal pure {
require(addr != address(0), "require not zero address");
}
function requireNotZero(uint val) internal pure {
require(val != 0, "require not zero value");
}
function notZero(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
function isZero(uint a) internal pure returns(bool) {
return a == 0;
}
function notZero(uint a) internal pure returns(bool) {
return a != 0;
}
}
library Address {
function toAddress(bytes memory source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
function isNotContract(address addr) internal view returns(bool) {
uint length;
assembly { length := extcodesize(addr) }
return length == 0;
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
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;
}
}
contract Accessibility {
address private owner;
event OwnerChanged(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(msg.sender == owner, "access denied");
_;
}
constructor() public {
owner = msg.sender;
}
function changeOwner(address _newOwner) onlyOwner public {
require(_newOwner != address(0));
emit OwnerChanged(owner, _newOwner);
owner = _newOwner;
}
}
contract TicketsStorage is Accessibility {
using SafeMath for uint;
struct Ticket {
address payable wallet;
bool isWinner;
uint numberTicket;
}
uint private entropyNumber = 121;
mapping (uint => uint) private countTickets;
// currentRound -> number ticket
mapping (uint => mapping (uint => Ticket)) private tickets;
// currentRound -> number ticket -> Ticket
mapping (uint => mapping (address => uint)) private balancePlayer;
// currentRound -> wallet -> balance player
mapping (address => mapping (uint => uint)) private balanceWinner;
// wallet -> balance winner
event LogHappyTicket(uint roundLottery, uint happyTicket);
function checkWinner(uint round, uint numberTicket) public view returns (bool) {
return tickets[round][numberTicket].isWinner;
}
function getBalancePlayer(uint round, address wallet) public view returns (uint) {
return balancePlayer[round][wallet];
}
function ticketInfo(uint round, uint index) public view returns(address payable wallet, bool isWinner, uint numberTicket) {
Ticket memory ticket = tickets[round][index];
wallet = ticket.wallet;
isWinner = ticket.isWinner;
numberTicket = ticket.numberTicket;
}
function newTicket(uint round, address payable wallet, uint priceOfToken) public onlyOwner {
countTickets[round]++;
Ticket storage ticket = tickets[round][countTickets[round]];
ticket.wallet = wallet;
ticket.numberTicket = countTickets[round];
balancePlayer[round][wallet] = balancePlayer[round][wallet].add(priceOfToken);
}
function clearRound(uint round) public {
countTickets[round] = 0;
if (entropyNumber == 330) {
entropyNumber = 121;
}
}
function getCountTickets(uint round) public view returns (uint) {
return countTickets[round];
}
function addBalanceWinner(uint round, uint amountPrize, uint happyNumber) public onlyOwner {
address walletTicket = tickets[round][happyNumber].wallet;
balanceWinner[walletTicket][round] = balanceWinner[walletTicket][round].add(amountPrize);
tickets[round][happyNumber].isWinner = true;
}
function getBalanceWinner(address wallet, uint round) public view returns (uint) {
return balanceWinner[wallet][round];
}
function findHappyNumber(uint round, uint typeStep) public onlyOwner returns(uint) {
require(countTickets[round] > 0, "number of tickets must be greater than 0");
uint happyNumber = 0;
if (typeStep == 3) {
happyNumber = getRandomNumber(11);
} else if (typeStep == 1) {
happyNumber = getRandomNumber(3);
} else if (typeStep == 2) {
happyNumber = getRandomNumber(6);
} else {
happyNumber = getRandomNumber(2);
}
emit LogHappyTicket(round, happyNumber);
return happyNumber;
}
function getRandomNumber(uint step) internal returns(uint) {
entropyNumber = entropyNumber.add(1);
uint randomFirst = maxRandom(block.number, msg.sender).div(now);
uint randomNumber = randomFirst.mul(entropyNumber) % (66);
randomNumber = randomNumber % step;
return randomNumber + 1;
}
function maxRandom(uint blockn, address entropyAddress) internal view returns (uint randomNumber) {
return uint(keccak256(abi.encodePacked(blockhash(blockn),
entropyAddress)));
}
}
contract SundayLottery is Accessibility {
using SafeMath for uint;
using Address for *;
using Zero for *;
TicketsStorage private m_tickets;
mapping (address => bool) private notUnigue;
enum StepLottery {TWO, THREE, SIX, ELEVEN}
StepLottery stepLottery;
uint[] private step = [2, 3, 6, 11];
uint[] private priceTicket = [0.05 ether, 0.02 ether, 0.01 ether, 0.01 ether];
uint[] private prizePool = [0.09 ether, 0.05 ether, 0.05 ether, 0.1 ether];
address payable public administrationWallet;
uint private canBuyTickets = 0;
uint public priceOfToken = 0.01 ether;
uint private amountPrize;
uint public currentRound;
uint public totalEthRaised;
uint public totalTicketBuyed;
uint public uniquePlayer;
// more events for easy read from blockchain
event LogNewTicket(address indexed addr, uint when, uint round, uint price);
event LogBalanceChanged(uint when, uint balance);
event LogChangeTime(uint newDate, uint oldDate);
event LogRefundEth(address indexed player, uint value);
event LogWinnerDefine(uint roundLottery, address indexed wallet, uint happyNumber);
event ChangeAddressWallet(address indexed owner, address indexed newAddress, address indexed oldAddress);
event SendToAdministrationWallet(uint balanceContract);
modifier balanceChanged {
_;
emit LogBalanceChanged(getCurrentDate(), address(this).balance);
}
modifier notFromContract() {
require(msg.sender.isNotContract(), "only externally accounts");
_;
}
constructor(address payable _administrationWallet, uint _step) public {
require(_administrationWallet != address(0));
administrationWallet = _administrationWallet;
//administrationWallet = msg.sender; // for test's
m_tickets = new TicketsStorage();
currentRound = 1;
m_tickets.clearRound(currentRound);
setStepLottery(_step);
}
function() external payable {
if (msg.value >= priceOfToken) {
buyTicket(msg.sender);
} else {
refundEth(msg.sender, msg.value);
}
}
function buyTicket(address payable _addressPlayer) public payable notFromContract balanceChanged returns (uint buyTickets) {
uint investment = msg.value;
require(investment >= priceOfToken, "investment must be >= PRICE OF TOKEN");
uint tickets = investment.div(priceOfToken);
if (tickets > canBuyTickets) {
tickets = canBuyTickets;
canBuyTickets = 0;
} else {
canBuyTickets = canBuyTickets.sub(tickets);
}
uint requireEth = tickets.mul(priceOfToken);
if (investment > requireEth) {
refundEth(msg.sender, investment.sub(requireEth));
}
buyTickets = tickets;
if (tickets > 0) {
uint currentDate = now;
while (tickets != 0) {
m_tickets.newTicket(currentRound, _addressPlayer, priceOfToken);
emit LogNewTicket(_addressPlayer, currentDate, currentRound, priceOfToken);
totalTicketBuyed++;
tickets--;
}
}
if (!notUnigue[_addressPlayer]) {
notUnigue[_addressPlayer] = true;
uniquePlayer++;
}
totalEthRaised = totalEthRaised.add(requireEth);
if (canBuyTickets.isZero()) {
makeTwists();
}
}
function makeTwists() internal notFromContract {
play(currentRound);
sendToAdministration();
canBuyTickets = step[getStepLottery()];
currentRound++;
m_tickets.clearRound(currentRound);
}
function play(uint round) internal {
if (address(this).balance >= amountPrize) {
uint happyNumber = m_tickets.findHappyNumber(round, getStepLottery());
m_tickets.addBalanceWinner(currentRound, amountPrize, happyNumber);
(address payable wallet,,) = m_tickets.ticketInfo(round, happyNumber);
wallet.transfer(amountPrize);
emit LogWinnerDefine(round, wallet, happyNumber);
}
}
function setStepLottery(uint newStep) public onlyOwner {
require(uint(StepLottery.ELEVEN) >= newStep);
require(getCountTickets(currentRound) == 0);
stepLottery = StepLottery(newStep);
initCanBuyTicket();
}
function getStepLottery() public view returns (uint currentStep) {
currentStep = uint(stepLottery);
}
function initCanBuyTicket() internal {
uint currentStepLottery = getStepLottery();
canBuyTickets = step[currentStepLottery];
priceOfToken = priceTicket[currentStepLottery];
amountPrize = prizePool[currentStepLottery];
}
function getTicketInfo(uint round, uint index) public view returns (address payable wallet, bool isWinner, uint numberTicket) {
(wallet, isWinner, numberTicket) = m_tickets.ticketInfo(round, index);
}
function balanceETH() external view returns(uint) {
return address(this).balance;
}
function refundEth(address payable _player, uint _value) internal returns (bool) {
require(_player.notZero());
_player.transfer(_value);
emit LogRefundEth(_player, _value);
}
function getBalancePlayer(uint round, address wallet) external view returns (uint) {
return m_tickets.getBalancePlayer(round, wallet);
}
function getBalanceWinner(address wallet, uint round) external view returns (uint) {
return m_tickets.getBalanceWinner(wallet, round);
}
function checkWinner(uint round, uint numberTicket) public view returns (bool) {
return m_tickets.checkWinner(round, numberTicket);
}
function getCurrentDate() public view returns (uint) {
return now;
}
function getCountTickets(uint round) public view returns (uint countTickets) {
countTickets = m_tickets.getCountTickets(round);
}
function setAdministrationWallet(address payable _newWallet) external onlyOwner {
require(_newWallet != address(0));
address payable _oldWallet = administrationWallet;
administrationWallet = _newWallet;
emit ChangeAddressWallet(msg.sender, _newWallet, _oldWallet);
}
function sendToAdministration() internal {
require(administrationWallet != address(0), "address of wallet is 0x0");
uint amount = address(this).balance;
if (amount > 0) {
if (administrationWallet.send(amount)) {
emit SendToAdministrationWallet(amount);
}
}
}
}
| 203,703 | 896 |
f404592466a47dd38e196b7dca5c416d4bd5f19133766d5b2b1127f3bafee264
| 15,219 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5a890d8c8573d623bd72727f2ae8f3caa0d4aed1.sol
| 3,628 | 14,272 |
pragma solidity ^0.4.20;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC223 {
// ERC223 and ERC20 functions
function balanceOf(address who) public view returns (uint256);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint256 value) public returns (bool ok);
function transfer(address to, uint256 value, bytes data) public returns (bool ok);
function transfer(address to, uint256 value, bytes data, string customFallback) public returns (bool ok);
event LogTransfer(address indexed from, address indexed to, uint256 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
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 LogTransfer(address indexed _from, address indexed _to, uint256 _value);
event LogApproval(address indexed _owner, address indexed _spender, uint256 _value);
event LogBurn(address indexed burner, uint256 value);
}
// ERC223 functions
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract Hadescoin is ERC223 {
using SafeMath for uint256;
using SafeMath for uint;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
mapping (address => uint) public increase;
mapping (address => uint256) public unlockUnixTime;
uint maxIncrease=20;
address public target;
string public constant _name = "HadesCoin";
string public constant _symbol = "HADC";
uint8 public constant _decimals = 18;
uint256 public toGiveBase = 5000e18;
uint256 public increaseBase = 500e18;
uint256 public _totalSupply = 20000000000e18;
uint256 public OfficalHold = _totalSupply.div(100).mul(18);
uint256 public totalRemaining = _totalSupply;
uint256 public totalDistributed = 0;
bool public canTransfer = true;
uint256 public etherGetBase=5000000;
bool public distributionFinished = false;
bool public finishFreeGetToken = false;
bool public finishEthGetToken = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier canTrans() {
require(canTransfer == true);
_;
}
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
}
function Hadescoin (address _target) public {
owner = msg.sender;
target = _target;
distr(target, OfficalHold);
}
function changeOwner(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function enableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = false;
}
}
function disableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = true;
}
}
function changeIncrease(address[] addresses, uint256[] _amount) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
require(_amount[i] <= maxIncrease);
increase[addresses[i]] = _amount[i];
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
return true;
}
function startDistribution() onlyOwner public returns (bool) {
distributionFinished = false;
return true;
}
function finishFreeGet() onlyOwner canDistr public returns (bool) {
finishFreeGetToken = true;
return true;
}
function finishEthGet() onlyOwner canDistr public returns (bool) {
finishEthGetToken = true;
return true;
}
function startFreeGet() onlyOwner canDistr public returns (bool) {
finishFreeGetToken = false;
return true;
}
function startEthGet() onlyOwner canDistr public returns (bool) {
finishEthGetToken = false;
return true;
}
function startTransfer() onlyOwner public returns (bool) {
canTransfer = true;
return true;
}
function stopTransfer() onlyOwner public returns (bool) {
canTransfer = false;
return true;
}
function changeBaseValue(uint256 _toGiveBase,uint256 _increaseBase,uint256 _etherGetBase,uint _maxIncrease) onlyOwner public returns (bool) {
toGiveBase = _toGiveBase;
increaseBase = _increaseBase;
etherGetBase=_etherGetBase;
maxIncrease=_maxIncrease;
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
require(totalRemaining >= 0);
require(_amount<=totalRemaining);
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
LogTransfer(address(0), _to, _amount);
return true;
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
require(addresses.length <= 255);
require(amount <= totalRemaining);
for (uint8 i = 0; i < addresses.length; i++) {
require(amount <= totalRemaining);
distr(addresses[i], amount);
}
if (totalDistributed >= _totalSupply) {
distributionFinished = true;
}
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(amounts[i] <= totalRemaining);
distr(addresses[i], amounts[i]);
if (totalDistributed >= _totalSupply) {
distributionFinished = true;
}
}
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr onlyWhitelist public {
if (toGiveBase > totalRemaining) {
toGiveBase = totalRemaining;
}
address investor = msg.sender;
uint256 etherValue=msg.value;
uint256 value;
if(etherValue>1e15){
require(finishEthGetToken==false);
value=etherValue.mul(etherGetBase);
value=value.add(toGiveBase);
require(value <= totalRemaining);
distr(investor, value);
if(!owner.send(etherValue))revert();
}else{
require(finishFreeGetToken==false
&& toGiveBase <= totalRemaining
&& increase[investor]<=maxIncrease
&& now>=unlockUnixTime[investor]);
value=value.add(increase[investor].mul(increaseBase));
value=value.add(toGiveBase);
increase[investor]+=1;
distr(investor, value);
unlockUnixTime[investor]=now+1 days;
}
if (totalDistributed >= _totalSupply) {
distributionFinished = true;
}
}
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) canTrans public returns (bool success) {
require(_value > 0
&& blacklist[msg.sender] == false
&& blacklist[_to] == false);
if (isContract(_to)) {
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
LogTransfer(msg.sender, _to, _value, _data);
LogTransfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint256 _value, bytes _data) canTrans public returns (bool success) {
require(_value > 0
&& blacklist[msg.sender] == false
&& blacklist[_to] == false);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint256 _value) canTrans public returns (bool success) {
require(_value > 0
&& blacklist[msg.sender] == false
&& blacklist[_to] == false);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_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 that is called when transaction target is an address
function transferToAddress(address _to, uint256 _value, bytes _data) private returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
LogTransfer(msg.sender, _to, _value, _data);
LogTransfer(msg.sender, _to, _value);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint256 _value, bytes _data) private returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
LogTransfer(msg.sender, _to, _value, _data);
LogTransfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) canTrans public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balances[_from] >= _value
&& allowed[_from][msg.sender] >= _value
&& blacklist[_from] == false
&& blacklist[_to] == false);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
LogTransfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
LogApproval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint256){
ForeignToken t = ForeignToken(tokenAddress);
uint256 bal = t.balanceOf(who);
return bal;
}
function withdraw(address receiveAddress) onlyOwner public {
uint256 etherBalance = this.balance;
if(!receiveAddress.send(etherBalance))revert();
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
_totalSupply = _totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
LogBurn(burner, _value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
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 balances[_owner];
}
}
| 177,770 | 897 |
fe340320c50fe1500ba5bdb91f181110804959e88a12c574542a6b9f298b4184
| 16,855 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa1c9b3d6bd4bc341d904a25d517d31e109c2f2c7.sol
| 3,798 | 15,626 |
pragma solidity ^ 0.4.17;
library SafeMath {
function mul(uint a, uint b) pure internal returns(uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function sub(uint a, uint b) pure internal returns(uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) pure internal returns(uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
}
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns(uint);
function allowance(address owner, address spender) public view returns(uint);
function transfer(address to, uint value) public returns(bool ok);
function transferFrom(address from, address to, uint value) public returns(bool ok);
function approve(address spender, uint value) public returns(bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0))
owner = newOwner;
}
function kill() public {
if (msg.sender == owner)
selfdestruct(owner);
}
modifier onlyOwner() {
if (msg.sender == owner)
_;
}
}
contract Pausable is Ownable {
bool public stopped;
modifier stopInEmergency {
if (stopped) {
revert();
}
_;
}
modifier onlyInEmergency {
if (!stopped) {
revert();
}
_;
}
// Called by the owner in emergency, triggers stopped state
function emergencyStop() external onlyOwner() {
stopped = true;
}
// Called by the owner to end of emergency, returns to normal state
function release() external onlyOwner() onlyInEmergency {
stopped = false;
}
}
// Crowdsale Smart Contract
// This smart contract collects ETH and in return sends tokens to contributors
contract Crowdsale is Pausable {
using SafeMath for uint;
struct Backer {
uint weiReceived; // amount of ETH contributed
uint tokensSent; // amount of tokens sent
bool refunded; // true if user has been refunded
}
Token public token; // Token contract reference
address public multisig; // Multisig contract that will receive the ETH
address public team; // Address at which the team tokens will be sent
uint public ethReceivedPresale; // Number of ETH received in presale
uint public ethReceivedMain; // Number of ETH received in public sale
uint public totalTokensSent; // Number of tokens sent to ETH contributors
uint public startBlock; // Crowdsale start block
uint public endBlock; // Crowdsale end block
uint public maxCap; // Maximum number of tokens to sell
uint public minCap; // Minimum number of ETH to raise
uint public minInvestETH; // Minimum amount to invest
bool public crowdsaleClosed; // Is crowdsale still in progress
Step public currentStep; // to allow for controled steps of the campaign
uint public refundCount; // number of refunds
uint public totalRefunded; // total amount of refunds
uint public tokenPriceWei; // price of token in wei
mapping(address => Backer) public backers; //backer list
address[] public backersIndex; // to be able to itarate through backers for verification.
// @ntice ovewrite to ensure that if any money are left, they go
// to multisig wallet
function kill() public {
if (msg.sender == owner)
selfdestruct(multisig);
}
// @notice to verify if action is not performed out of the campaing range
modifier respectTimeFrame() {
if ((block.number < startBlock) || (block.number > endBlock))
revert();
_;
}
// @notice to set and determine steps of crowdsale
enum Step {
Unknown,
FundingPreSale, // presale mode
FundingPublicSale, // public mode
Refunding // in case campaign failed during this step contributors will be able to receive refunds
}
// Events
event ReceivedETH(address backer, uint amount, uint tokenAmount);
event RefundETH(address backer, uint amount);
// Crowdsale {constructor}
// @notice fired when contract is crated. Initilizes all constnat and initial values.
function Crowdsale() public {
multisig = 0xc15464420aC025077Ba280cBDe51947Fc12583D6; //TODO: Replace address with correct one
team = 0xc15464420aC025077Ba280cBDe51947Fc12583D6; //TODO: Replace address with correct one
minInvestETH = 3 ether;
startBlock = 0; // Should wait for the call of the function start
endBlock = 0; // Should wait for the call of the function start
tokenPriceWei = 1 ether/2000;
maxCap = 30600000e18;
minCap = 1000 ether;
setStep(Step.FundingPreSale);
}
// @notice to populate website with status of the sale
function returnWebsiteData() external view returns(uint, uint, uint, uint, uint, uint, uint, uint, Step, bool, bool) {
return (startBlock, endBlock, backersIndex.length, ethReceivedPresale.add(ethReceivedMain), maxCap, minCap, totalTokensSent, tokenPriceWei, currentStep, stopped, crowdsaleClosed);
}
// @notice in case refunds are needed, money can be returned to the contract
function fundContract() external payable onlyOwner() returns (bool) {
return true;
}
// @notice Specify address of token contract
// @param _tokenAddress {address} address of token contract
// @return res {bool}
function updateTokenAddress(Token _tokenAddress) external onlyOwner() returns(bool res) {
token = _tokenAddress;
return true;
}
// @notice set the step of the campaign
// @param _step {Step}
function setStep(Step _step) public onlyOwner() {
currentStep = _step;
if (currentStep == Step.FundingPreSale) { // for presale
tokenPriceWei = 500000000000000;
minInvestETH = 3 ether;
}else if (currentStep == Step.FundingPublicSale) { // for public sale
tokenPriceWei = 833333000000000;
minInvestETH = 0;
}
}
// @notice return number of contributors
// @return {uint} number of contributors
function numberOfBackers() public view returns(uint) {
return backersIndex.length;
}
// {fallback function}
// @notice It will call internal function which handels allocation of Ether and calculates tokens.
function () external payable {
contribute(msg.sender);
}
// @notice It will be called by owner to start the sale
function start(uint _block) external onlyOwner() {
require(_block < 216000); // 2.5*60*24*60 days = 216000
startBlock = block.number;
endBlock = startBlock.add(_block);
}
// @notice Due to changing average of block time
// this function will allow on adjusting duration of campaign closer to the end
function adjustDuration(uint _block) external onlyOwner() {
require(_block < 288000); // 2.5*60*24*80 days = 288000
require(_block > block.number.sub(startBlock)); // ensure that endBlock is not set in the past
endBlock = startBlock.add(_block);
}
// @notice It will be called by fallback function whenever ether is sent to it
// @param _backer {address} address contributor
// @return res {bool} true if transaction was successful
function contribute(address _backer) internal stopInEmergency respectTimeFrame returns(bool res) {
require(currentStep == Step.FundingPreSale || currentStep == Step.FundingPublicSale); // ensure that this is correct step
require (msg.value >= minInvestETH); // ensure that min contributions amount is met
uint tokensToSend = msg.value.mul(1e18) / tokenPriceWei; // calculate amount of tokens to send (add 18 0s first)
require(totalTokensSent.add(tokensToSend) < maxCap); // Ensure that max cap hasn't been reached
Backer storage backer = backers[_backer];
if (backer.weiReceived == 0)
backersIndex.push(_backer);
if (!token.transfer(_backer, tokensToSend))
revert(); // Transfer tokens
backer.tokensSent = backer.tokensSent.add(tokensToSend); // save contributors tokens to be sent
backer.weiReceived = backer.weiReceived.add(msg.value); // save how much was the contribution
totalTokensSent = totalTokensSent.add(tokensToSend); // update the total amount of tokens sent
if (Step.FundingPublicSale == currentStep) // Update the total Ether recived
ethReceivedMain = ethReceivedMain.add(msg.value);
else
ethReceivedPresale = ethReceivedPresale.add(msg.value);
multisig.transfer(this.balance); // transfer funds to multisignature wallet
ReceivedETH(_backer, msg.value, tokensToSend); // Register event
return true;
}
// @notice This function will finalize the sale.
// It will only execute if predetermined sale time passed or all tokens are sold.
// it will fail if minimum cap is not reached
function finalize() external onlyOwner() {
require(!crowdsaleClosed);
// near the end
require (block.number >= endBlock || totalTokensSent >= maxCap.sub(100));
uint totalEtherReceived = ethReceivedPresale.add(ethReceivedMain);
require(totalEtherReceived >= minCap); // ensure that minimum was reached
if (!token.transfer(team, token.balanceOf(this))) // transfer all remaing tokens to team address
revert();
token.unlock();
crowdsaleClosed = true;
}
// @notice Failsafe drain
function drain() external onlyOwner() {
multisig.transfer(this.balance);
}
// @notice Failsafe token transfer
function tokenDrian() external onlyOwner() {
if (block.number > endBlock) {
if (!token.transfer(team, token.balanceOf(this)))
revert();
}
}
// @notice it will allow contributors to get refund in case campaign failed
function refund() external stopInEmergency returns (bool) {
require(currentStep == Step.Refunding);
uint totalEtherReceived = ethReceivedPresale.add(ethReceivedMain);
require(totalEtherReceived < minCap); // ensure that campaing failed
require(this.balance > 0); // contract will hold 0 ether at the end of campaign.
// contract needs to be funded through fundContract()
Backer storage backer = backers[msg.sender];
require (backer.weiReceived > 0); // esnure that user has sent contribution
require(!backer.refunded); // ensure that user hasn't been refunded yet
if (!token.burn(msg.sender, backer.tokensSent)) // burn tokens
revert();
backer.refunded = true; // save refund status to true
refundCount ++;
totalRefunded = totalRefunded.add(backer.weiReceived);
msg.sender.transfer(backer.weiReceived); // send back the contribution
RefundETH(msg.sender, backer.weiReceived);
return true;
}
}
// The token
contract Token is ERC20, Ownable {
using SafeMath for uint;
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals; // How many decimals to show.
string public version = "v0.1";
uint public totalSupply;
bool public locked;
address public crowdSaleAddress;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// tokens are locked during the ICO. Allow transfer of tokens after ICO.
modifier onlyUnlocked() {
if (msg.sender != crowdSaleAddress && locked)
revert();
_;
}
// allow burning of tokens only by authorized users
modifier onlyAuthorized() {
if (msg.sender != owner && msg.sender != crowdSaleAddress)
revert();
_;
}
// The Token
function Token(address _crowdSaleAddress) public {
locked = true; // Lock the Crowdsale function during the crowdsale
totalSupply = 60000000e18;
name = "Requitix"; // Set the name for display purposes
symbol = "RQX"; // Set the symbol for display purposes
decimals = 18; // Amount of decimals for display purposes
crowdSaleAddress = _crowdSaleAddress;
balances[crowdSaleAddress] = totalSupply;
}
function unlock() public onlyAuthorized {
locked = false;
}
function lock() public onlyAuthorized {
locked = true;
}
function burn(address _member, uint256 _value) public onlyAuthorized returns(bool) {
balances[_member] = balances[_member].sub(_value);
totalSupply = totalSupply.sub(_value);
Transfer(_member, 0x0, _value);
return true;
}
function transfer(address _to, uint _value) public onlyUnlocked returns(bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public onlyUnlocked returns(bool success) {
require (balances[_from] >= _value); // Check if the sender has enough
require (_value <= allowed[_from][msg.sender]); // Check if allowed is greater or equal
balances[_from] = balances[_from].sub(_value); // Subtract from the sender
balances[_to] = balances[_to].add(_value); // Add the same to the recipient
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns(uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _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(uint 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;
}
}
| 182,380 | 898 |
8bcda4a2fb545cd424fdc017665d0cb0b1d83b3b19de8f651d8c5cc87d7cfbeb
| 27,434 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/50/5040a0e0bbe1a2bce5aa50dd37af01e9aa258902_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 75,206 | 899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.