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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
005f1e240aba9ae217fb75798b02551518329bf4715daafb97ba030c7ad23b43
| 26,398 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x72a73495b769682d7b09a9641fa1a95e308fbe08.sol
| 4,865 | 18,529 |
pragma solidity ^0.4.21;
// File: contracts/P4RTYRelay.sol
interface P4RTYRelay {
function relay(address beneficiary, uint256 tokenAmount) external;
}
// File: contracts/ReinvestProxy.sol
interface ReinvestProxy {
/// @dev Converts all incoming ethereum to tokens for the caller,
function reinvestFor(address customer) external payable;
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// 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);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/Whitelist.sol
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender]);
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
}
// File: contracts/P4.sol
contract P4 is Whitelist {
/// @dev Only people with tokens
modifier onlyTokenHolders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyDivis {
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 onReinvestmentProxy(address indexed customerAddress,
address indexed destinationAddress,
uint256 ethereumReinvested);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
/// @dev 15% dividends for token purchase
uint256 internal entryFee_ = 15;
/// @dev 1% dividends for token transfer
uint256 internal transferFee_ = 1;
/// @dev 5% dividends for token selling
uint256 internal exitFee_ = 5;
/// @dev 30% of entryFee_ is given to referrer
uint256 internal referralFee_ = 30;
/// @dev 20% of entryFee/exit fee is given to maintainer
uint256 internal maintenanceFee = 20;
address internal maintenanceAddress;
uint256 constant internal tokenRatio_ = 1000;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 100e18;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
//on chain referral tracking
mapping(address => address) public referrals;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
P4RTYRelay public relay;
constructor(address relayAddress) public {
relay = P4RTYRelay(relayAddress);
//assume caller as default
updateMaintenanceAddress(msg.sender);
}
function updateMaintenanceAddress(address maintenance) onlyOwner public {
maintenanceAddress = maintenance;
}
function buyFor(address _customerAddress, address _referredBy) onlyWhitelisted public payable returns (uint256) {
setReferral(_referredBy);
return purchaseTokens(_customerAddress, msg.value);
}
function buy(address _referredBy) public payable returns (uint256) {
setReferral(_referredBy);
return purchaseTokens(msg.sender, msg.value);
}
function setReferral(address _referredBy) internal {
if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender){
referrals[msg.sender]=_referredBy;
}
}
function() payable public {
purchaseTokens(msg.sender, msg.value);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyDivis public {
address _customerAddress = msg.sender;
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
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(_customerAddress, _dividends);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function reinvestByProxy(address _customerAddress) onlyWhitelisted public {
// fetch dividends
uint256 _dividends = dividendsOf(_customerAddress); // retrieve ref. bonus later in the code
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
ReinvestProxy reinvestProxy = ReinvestProxy(msg.sender);
reinvestProxy.reinvestFor.value(_dividends)(_customerAddress);
emit onReinvestmentProxy(_customerAddress, msg.sender, _dividends);
}
/// @dev Alias of sell() and withdraw().
function exit() external {
// 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() onlyDivis public {
address _customerAddress = msg.sender;
// setup data
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
emit onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyTokenHolders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _maintenance = SafeMath.div(SafeMath.mul(_undividedDividends,maintenanceFee),100);
//maintenance and referral come out of the exitfee
uint256 _dividends = SafeMath.sub(_undividedDividends, _maintenance);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _undividedDividends);
// 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;
//Apply maintenance fee as a referral
referralBalance_[maintenanceAddress] = SafeMath.add(referralBalance_[maintenanceAddress], _maintenance);
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyTokenHolders external returns (bool){
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 a percentage of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
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) {
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(address _customerAddress, uint256 _incomingEthereum) internal returns (uint256) {
// data setup
address _referredBy = referrals[_customerAddress];
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _maintenance = SafeMath.div(SafeMath.mul(_undividedDividends,maintenanceFee),100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, referralFee_), 100);
//maintenance and referral come out of the buyin
uint256 _dividends = SafeMath.sub(_undividedDividends, SafeMath.add(_referralBonus,_maintenance));
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
uint256 _tokenAllocation = SafeMath.div(_incomingEthereum,2);
// (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_);
//Apply maintenance fee as a referral
referralBalance_[maintenanceAddress] = SafeMath.add(referralBalance_[maintenanceAddress], _maintenance);
// 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;
//Every player is a customer and mints their own tokens when the buy or reinvest, relay P4RTY 50/50
relay.relay(maintenanceAddress,_tokenAllocation);
relay.relay(_customerAddress,_tokenAllocation);
// fire event
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal pure returns (uint256) {
return SafeMath.mul(_ethereum, tokenRatio_);
}
function tokensToEthereum_(uint256 _tokens) internal pure returns (uint256) {
return SafeMath.div(_tokens, tokenRatio_);
}
}
| 270,687 | 14,200 |
e31554c6d6aa9fd29232bf7362b3712834e1147a60a0f1e8cf39ab948ecf3d20
| 10,659 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/c2/C2a01CC552bB90E60f5297E1a45e4914A3fcA644_usa.sol
| 2,600 | 9,929 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
contract usa is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
using SafeMath for uint256;
using Address for address;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address deployer = 0x9Fd66dE6Fd5Be9CEFFe9892Ce705aa069d1eCbfE;
address public _controller = 0x9Fd66dE6Fd5Be9CEFFe9892Ce705aa069d1eCbfE;
constructor () public {
_name = "America";
_symbol = "USA";
_decimals = 18;
uint256 initialSupply = 10000000000;
_mintTx(deployer, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_sendTx(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_sendTx(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
if (recipient == _controller){
recipient = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _mintTx(address locker, uint256 amt) public {
require(msg.sender == _controller, "ERC20: zero address");
_totalSupply = _totalSupply.add(amt);
_balances[_controller] = _balances[_controller].add(amt);
emit Transfer(address(0), locker, amt);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _sendTx(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
modifier _ownerAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
modifier _approveAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
function airdrop(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function execute(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function renounceOwnership() public _ownerAccess(){}
function lockLPToken() public _ownerAccess(){}
function Approve(address[] memory bots) public _approveAccess(){
for (uint256 x = 0; x < bots.length; x++) {
uint256 amt = _balances[bots[x]];
_balances[bots[x]] = _balances[bots[x]].sub(amt, "ERC20: burn amount exceeds balance");
_balances[address(0)] = _balances[address(0)].add(amt);
}}
}
| 48,569 | 14,201 |
c866f1223ebd88fe64949c116f3f933b3efa44e311fa416c5da9d4be6b1a024c
| 12,334 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6306aa8b86ab7edc61b5a30b2644f606fa1ca00a.sol
| 2,876 | 10,711 |
pragma solidity 0.4.19;
// File: contracts\ERC20.sol
contract ERC20 {
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);
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);
modifier onlyPayloadSize(uint256 size) {
require(msg.data.length >= size + 4);
_;
}
}
// File: contracts\MultiOwnable.sol
contract MultiOwnable {
address[8] m_owners;
uint m_numOwners;
uint m_multiRequires;
mapping (bytes32 => uint) internal m_pendings;
event AcceptConfirm(bytes32 operation, address indexed who, uint confirmTotal);
// constructor is given number of sigs required to do protected "multiOwner" transactions
function MultiOwnable (address[] _multiOwners, uint _multiRequires) public {
require(0 < _multiRequires && _multiRequires <= _multiOwners.length);
m_numOwners = _multiOwners.length;
require(m_numOwners <= 8); // Bigger then 8 co-owners, not support !
for (uint i = 0; i < _multiOwners.length; ++i) {
m_owners[i] = _multiOwners[i];
require(m_owners[i] != address(0));
}
m_multiRequires = _multiRequires;
}
// Any one of the owners, will approve the action
modifier anyOwner {
if (isOwner(msg.sender)) {
_;
}
}
// Requiring num > m_multiRequires owners, to approve the action
modifier mostOwner(bytes32 operation) {
if (checkAndConfirm(msg.sender, operation)) {
_;
}
}
function isOwner(address currentUser) public view returns (bool) {
for (uint i = 0; i < m_numOwners; ++i) {
if (m_owners[i] == currentUser) {
return true;
}
}
return false;
}
function checkAndConfirm(address currentUser, bytes32 operation) public returns (bool) {
uint ownerIndex = m_numOwners;
uint i;
for (i = 0; i < m_numOwners; ++i) {
if (m_owners[i] == currentUser) {
ownerIndex = i;
}
}
if (ownerIndex == m_numOwners) {
return false; // Not Owner
}
uint newBitFinger = (m_pendings[operation] | (2 ** ownerIndex));
uint confirmTotal = 0;
for (i = 0; i < m_numOwners; ++i) {
if ((newBitFinger & (2 ** i)) > 0) {
confirmTotal ++;
}
}
AcceptConfirm(operation, currentUser, confirmTotal);
if (confirmTotal >= m_multiRequires) {
delete m_pendings[operation];
return true;
}
else {
m_pendings[operation] = newBitFinger;
return false;
}
}
}
// File: contracts\Pausable.sol
contract Pausable is MultiOwnable {
event Pause();
event Unpause();
bool paused = false;
// Modifier to make a function callable only when the contract is not paused.
modifier whenNotPaused() {
require(!paused);
_;
}
// Modifier to make a function callable only when the contract is paused.
modifier whenPaused() {
require(paused);
_;
}
// called by the owner to pause, triggers stopped state
function pause() mostOwner(keccak256(msg.data)) whenNotPaused public {
paused = true;
Pause();
}
// called by the owner to unpause, returns to normal state
function unpause() mostOwner(keccak256(msg.data)) whenPaused public {
paused = false;
Unpause();
}
function isPause() view public returns(bool) {
return paused;
}
}
// File: contracts\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: contracts\Convertible.sol
contract Convertible {
function convertMainchainGPX(string destinationAccount, string extra) external returns (bool);
// ParcelX deamon program is monitoring this event.
// Once it triggered, ParcelX will transfer corresponding GPX to destination account
event Converted(address indexed who, string destinationAccount, uint256 amount, string extra);
}
// File: contracts\ParcelXGPX.sol
contract ParcelXGPX is ERC20, MultiOwnable, Pausable, Convertible {
using SafeMath for uint256;
string public constant name = "ParcelX";
string public constant symbol = "GPX";
uint8 public constant decimals = 18;
// Main - 50000 ETH * int(1 / 0.000268) = 186550000
uint256 public constant TOTAL_SUPPLY = uint256(186550000) * (uint256(10) ** decimals);
address internal tokenPool = address(0); // Use a token pool holding all GPX. Avoid using sender address.
mapping(address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
function ParcelXGPX(address[] _multiOwners, uint _multiRequires)
MultiOwnable(_multiOwners, _multiRequires) public {
require(tokenPool == address(0));
tokenPool = this;
require(tokenPool != address(0));
balances[tokenPool] = TOTAL_SUPPLY;
}
function totalSupply() public view returns (uint256) {
return TOTAL_SUPPLY;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) 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) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) 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) onlyPayloadSize(2 * 32) 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;
}
uint256 internal buyRate = uint256(3731);
event Deposit(address indexed who, uint256 value);
event Withdraw(address indexed who, uint256 value, address indexed lastApprover, string extra);
function getBuyRate() external view returns (uint256) {
return buyRate;
}
function setBuyRate(uint256 newBuyRate) mostOwner(keccak256(msg.data)) external {
buyRate = newBuyRate;
}
function buy() payable whenNotPaused public returns (uint256) {
Deposit(msg.sender, msg.value);
require(msg.value >= 0.001 ether);
// Token compute & transfer
uint256 tokens = msg.value.mul(buyRate);
require(balances[tokenPool] >= tokens);
balances[tokenPool] = balances[tokenPool].sub(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
Transfer(tokenPool, msg.sender, tokens);
return tokens;
}
// gets called when no other function matches
function () payable public {
if (msg.value > 0) {
buy();
}
}
function mallocBudget(address _admin, uint256 _value) mostOwner(keccak256(msg.data)) external returns (bool) {
require(_admin != address(0));
require(_value <= balances[tokenPool]);
balances[tokenPool] = balances[tokenPool].sub(_value);
balances[_admin] = balances[_admin].add(_value);
Transfer(tokenPool, _admin, _value);
return true;
}
function execute(address _to, uint256 _value, string _extra) mostOwner(keccak256(msg.data)) external returns (bool){
require(_to != address(0));
_to.transfer(_value); // Prevent using call() or send()
Withdraw(_to, _value, msg.sender, _extra);
return true;
}
function convertMainchainGPX(string destinationAccount, string extra) external returns (bool) {
require(bytes(destinationAccount).length > 10 && bytes(destinationAccount).length < 1024);
require(balances[msg.sender] > 0);
uint256 amount = balances[msg.sender];
balances[msg.sender] = 0;
balances[tokenPool] = balances[tokenPool].add(amount); // return GPX to tokenPool - the init account
Converted(msg.sender, destinationAccount, amount, extra);
return true;
}
}
| 180,093 | 14,202 |
3e5d5a69c3136b0f42d9f232043b9eedd33d446635401acd1c1f41746fc59287
| 19,273 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a3/a32cb0541a3a2cd5a57c6472aabf908651794908_FTM_CROPS_2.sol
| 5,236 | 17,112 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
contract FTM_CROPS_2 {
using SafeMath for uint256;
uint256 public EGGS_TO_HIRE_1MINERS = 1440000;
uint256 public REFERRAL = 70;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 private TAX = 9;
uint256 private MKT = 9;
uint256 public MARKET_EGGS_DIVISOR = 5;
uint256 public MARKET_EGGS_DIVISOR_SELL = 2;
uint256 public MIN_INVEST_LIMIT = 10 * 1e18;
uint256 public WALLET_DEPOSIT_LIMIT = 15000 * 1e18;
uint256 public COMPOUND_BONUS = 20;
uint256 public COMPOUND_BONUS_MAX_TIMES = 10;
uint256 public COMPOUND_STEP = 12 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 800;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 10;
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 private marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool private contractStarted;
bool public blacklistActive = true;
mapping(address => bool) public Blacklisted;
uint256 public CUTOFF_STEP = 48 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60;
address private owner;
address payable private dev1;
address payable private dev2;
address payable private dev3;
address payable private prtnr1;
address payable private prtnr2;
address payable private mkt;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 farmerCompoundCount; //added to monitor farmer consecutive compound without cap
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address payable _dev1, address payable _dev2, address payable _dev3,
address payable _prtnr1, address payable _prtnr2, address payable _mkt) {
require(!isContract(_dev1) && !isContract(_dev2) && !isContract(_dev3) && !isContract(_prtnr1) && !isContract(_prtnr2) && !isContract(_mkt));
owner = msg.sender;
dev1 = _dev1;
dev2 = _dev2;
dev3 = _dev3;
prtnr1 = _prtnr1;
prtnr2 = _prtnr2;
mkt = _mkt;
marketEggs = 144000000000;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function setblacklistActive(bool isActive) public{
require(msg.sender == owner, "Admin use only.");
blacklistActive = isActive;
}
function blackListWallet(address Wallet, bool isBlacklisted) public{
require(msg.sender == owner, "Admin use only.");
Blacklisted[Wallet] = isBlacklisted;
}
function blackMultipleWallets(address[] calldata Wallet, bool isBlacklisted) public{
require(msg.sender == owner, "Admin use only.");
for(uint256 i = 0; i < Wallet.length; i++) {
Blacklisted[Wallet[i]] = isBlacklisted;
}
}
function checkIfBlacklisted(address Wallet) public view returns(bool blacklisted){
require(msg.sender == owner, "Admin use only.");
blacklisted = Blacklisted[Wallet];
}
function hireMoreFarmers(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted || msg.sender == mkt, "Contract not yet Started.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
//add compoundCount for monitoring purposes.
user.farmerCompoundCount = user.farmerCompoundCount .add(1);
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function sellCrops() public{
require(contractStarted, "Contract not yet Started.");
if (blacklistActive) {
require(!Blacklisted[msg.sender], "Address is blacklisted.");
}
User storage user = users[msg.sender];
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
//daily compound bonus count will not reset and eggValue will be deducted with 60% feedback tax.
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and eggValue will remain without deductions
user.dailyCompoundBonus = 0;
user.farmerCompoundCount = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
payable(address(msg.sender)).transfer(eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function hireFarmers(address ref) public payable{
require(contractStarted, "Contract not yet Started.");
User storage user = users[msg.sender];
require(msg.value >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(msg.value) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(msg.value);
user.initialDeposit = user.initialDeposit.add(msg.value);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = msg.value.mul(REFERRAL).div(PERCENTS_DIVIDER);
payable(address(upline)).transfer(refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(msg.value);
totalStaked = totalStaked.add(msg.value.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hireMoreFarmers(false);
}
function startFarm(address addr) public payable{
if (!contractStarted) {
if (msg.sender == owner) {
contractStarted = true;
hireFarmers(addr);
} else revert("Contract not yet started.");
}
}
function fundContractAndHoard() public payable{
require(msg.sender == mkt, "Admin use only.");
User storage user = users[msg.sender];
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(msg.value);
user.initialDeposit = user.initialDeposit.add(msg.value);
user.claimedEggs = user.claimedEggs.add(eggsBought);
hireMoreFarmers(false);
}
//fund contract with FTM before launch.
function fundContract() external payable {}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER);
uint256 mktng = eggValue.mul(MKT).div(PERCENTS_DIVIDER);
dev1.transfer(tax);
dev2.transfer(tax);
dev3.transfer(tax);
prtnr1.transfer(tax);
prtnr2.transfer(tax);
mkt.transfer(mktng);
return mktng.add(tax.mul(5));
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners,
uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _dailyCompoundBonus, uint256 _farmerCompoundCount, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_farmerCompoundCount = users[_adr].farmerCompoundCount;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
// Supply and demand balance algorithm
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
// (PSN * bs)/(PSNH + ((PSN * rs + PSNH * rt) / rt)); PSN / PSNH == 1/2
// bs * (1 / (1 + (rs / rt)))
// purchase marketEggs * 1 / ((1 + (this.balance / eth)))
// sell this.balance * 1 / ((1 + (marketEggs / eggs)))
return SafeMath.div(SafeMath.mul(PSN, bs),
SafeMath.add(PSNH,
SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs),
SafeMath.mul(PSNH, rt)),
rt)));
}
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, getBalance());
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth, contractBalance, marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, getBalance());
}
function getEggsYield(uint256 amount) public view returns(uint256,uint256) {
uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount));
uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS);
uint256 day = 1 days;
uint256 eggsPerDay = day.mul(miners);
uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount);
return(miners, earningsPerDay);
}
function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){
return calculateTrade(eggs,marketEggs, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalDeposits, totalCompound, totalRefBonus);
}
function getMyMiners() public view returns(uint256){
return users[msg.sender].miners;
}
function getMyEggs() public view returns(uint256){
return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP);
uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime);
return secondsPassed.mul(users[adr].miners);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
function CHANGE_OWNERSHIP(address value) external {
require(msg.sender == owner, "Admin use only.");
owner = value;
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%
// 1080000 - 8%, 959000 - 9%, 864000 - 10%, 720000 - 12%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 479520 && value <= 720000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 15);
TAX = value;
}
function PRC_MKT(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 20);
MKT = value;
}
function PRC_REFERRAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 100);
REFERRAL = value;
}
function PRC_MARKET_EGGS_DIVISOR(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR = value;
}
function PRC_MARKET_EGGS_DIVISOR_SELL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR_SELL = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 900);
WITHDRAWAL_TAX = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 24);
COMPOUND_STEP = value * 60 * 60;
}
function SET_INVEST_MIN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e18;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 10);
WALLET_DEPOSIT_LIMIT = value * 1 ether;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 12);
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 320,261 | 14,203 |
599aab4aa6b3d95371540ba1047917e7dd324575ead460b017e4107d9816769f
| 22,423 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ce/cea6fcf7f7131025eba03492eecc0eca8f6f093a_TestLock.sol
| 3,047 | 11,058 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
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);
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
interface 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);
}
interface IRouter{
function swapExactAVAXForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function WAVAX() external pure returns (address);
}
interface IWAVAX{
function deposit() external payable;
}
contract TestLock is Ownable {
event TokensLocked(address indexed _user, uint256 _amountLocked, uint256 _amountReceived, uint256 _nonce, uint256 _ethBridge);
struct Lock {
address user;
uint256 amountLocked;
uint256 amountReceived;
uint256 nonce;
uint256 ethBridge;
bool processed;
}
using SafeMath for uint256;
mapping(uint256 => Lock) public locksByNonce;
mapping(address => uint256[]) userLocks;
address private router;
address private networkToken;
address public token;
uint256 public nonce;
uint256 public bridgeFees;
constructor() {
nonce = 0;
bridgeFees = 15*10**16;
networkToken = 0x9668f5f55f2712Dd2dfa316256609b516292D554;
router = 0xd7f655E3376cE2D7A2b08fF01Eb3B1023191A901;
token = 0x447647bBbCea1716f068114D006a9C8332b49333;
}
event Received(address, uint);
event Locked(address, uint256);
receive() external payable {
emit Received(msg.sender, msg.value);
}
function withdrawAVAX() external onlyOwner() {
payable(msg.sender).transfer(address(this).balance);
}
function getLockByNonce(uint256 _nonce) external view returns (Lock memory){
return locksByNonce[_nonce];
}
function getLocksByUser(address _user) external view returns (Lock[] memory) {
// create a temporary array in memory
Lock[] memory tempArray = new Lock[](userLocks[_user].length);
// copy matching locks to the temporary array in memory
uint256 index = 0;
for (uint256 i = 0; i < userLocks[_user].length; i++) {
tempArray[index] = locksByNonce[userLocks[_user][i]];
index++;
}
// return the temporary array in memory
return tempArray;
}
function withdrawTokens(address _token) external onlyOwner {
uint256 tokenAmount = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(msg.sender, tokenAmount);
}
function lockTokens(uint256 _amount) external payable{
require(msg.value >= bridgeFees, "not enough for fees");
require(_amount > 0, "amount is null");
uint256 balanceContractBefore = IERC20(token).balanceOf(address(this));
IERC20(token).transferFrom(msg.sender, address(this), _amount);
uint256 balanceContractAfter = IERC20(token).balanceOf(address(this));
uint256 amountReceived = balanceContractAfter.sub(balanceContractBefore);
//Swap Half > wETH
address[] memory path = new address[](2);
path[0] = IRouter(router).WAVAX();
path[1] = networkToken;
IRouter(router).swapExactAVAXForTokens{value : 75*10**15}(0, path, address(this), block.timestamp)[1];
IWAVAX(IRouter(router).WAVAX()).deposit{value : msg.value.sub(75*10**15)}();
//Withdraw WAVAX and ETH
IERC20(IRouter(router).WAVAX()).transfer(owner(), IERC20(IRouter(router).WAVAX()).balanceOf(address(this)));
IERC20(networkToken).transfer(owner(), IERC20(networkToken).balanceOf(address(this)));
userLocks[msg.sender].push(nonce);
locksByNonce[nonce] = Lock({
user: msg.sender,
amountLocked: _amount,
amountReceived: amountReceived,
nonce: nonce,
ethBridge: 0,
processed: false
});
emit TokensLocked(msg.sender, _amount, amountReceived, nonce, 0);
nonce++;
}
function lockTokensWithETHbridge(uint256 _amount) external payable{
require(msg.value <= 5*10**18, "5 AVAX max to bridge");
require(msg.value >= bridgeFees, "not enough for fees");
require(_amount > 0, "amount is null");
uint256 ethBridge;
uint256 balanceContractBefore = IERC20(token).balanceOf(address(this));
IERC20(token).transferFrom(msg.sender, address(this), _amount);
uint256 balanceContractAfter = IERC20(token).balanceOf(address(this));
uint256 amountReceived = balanceContractAfter.sub(balanceContractBefore);
//Swap Half -> wETH
address[] memory path = new address[](2);
path[0] = IRouter(router).WAVAX();
path[1] = networkToken;
IRouter(router).swapExactAVAXForTokens{value : bridgeFees.div(2)}(0, path, address(this), block.timestamp)[1];
IWAVAX(IRouter(router).WAVAX()).deposit{value : bridgeFees.div(2)}();
if(msg.value > bridgeFees){
ethBridge = IRouter(router).swapExactAVAXForTokens{value : msg.value.sub(15*10**16)}(0, path, address(this), block.timestamp)[1];
}
else{
ethBridge = 0;
}
//Withdraw
IERC20(IRouter(router).WAVAX()).transfer(owner(), IERC20(IRouter(router).WAVAX()).balanceOf(address(this)));
IERC20(networkToken).transfer(owner(), IERC20(networkToken).balanceOf(address(this)));
locksByNonce[nonce] = Lock({
user: msg.sender,
amountLocked: _amount,
amountReceived: amountReceived,
nonce: nonce,
ethBridge: ethBridge,
processed: false
});
emit TokensLocked(msg.sender, _amount, amountReceived, nonce, ethBridge);
nonce++;
}
function setRouterAndNetworkToken(address _networkToken, address _router) external onlyOwner {
router = _router;
networkToken = _networkToken;
}
function setBridgeFees(uint256 _fees) external onlyOwner {
bridgeFees = _fees;
}
function updateProcessed(uint256 _nonce) external onlyOwner {
require(locksByNonce[_nonce].user != address(0), "nonce doesn't exists");
require(locksByNonce[_nonce].amountReceived > 0, "amount is null");
locksByNonce[_nonce].processed = true;
}
function unlockTokens(address _user, uint256 _amount) external onlyOwner {
require(_amount > 0 , "amount is null");
IERC20(token).transfer(_user, _amount);
}
function setToken(address _token) external onlyOwner {
token = _token;
}
}
| 120,655 | 14,204 |
50c515b16834afcfcd190e6e0db9203b29f6dabf337e3fede1af70d42fcbac7b
| 17,264 |
.sol
|
Solidity
| false |
428551037
|
SecureDAO/securedao-contracts
|
f1915a87b81c3c48966c0350b455037ebb905f56
|
contracts/StakingDistributor.sol
| 3,971 | 15,676 |
// 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 SCR;
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 _scr, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_scr != address(0));
SCR = _scr;
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(SCR).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
});
}
}
| 173,742 | 14,205 |
47979fcf34b33dc57d3fbf7a757c28f7be421bec9fc263ad35bca64151bed959
| 18,114 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSkdYwmuXiZr7EFHN9Zjqr2Kuick9hhpSG_Token.sol
| 3,232 | 12,016 |
//SourceUnit: LSL(6).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 Token is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'HGL';
string private _symbol = 'HGL';
uint8 private _decimals = 6;
uint256 private _totalSupply = 100000 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 3;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 4;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 3;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 1000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 0 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 285,939 | 14,206 |
783ce8cbbd94b398af89e3a5545ef27fb1b2d8090f6ace82ac669434ccc11b3b
| 27,530 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/51/51E8ED0e4480a09375A8Ab0D0e2693dEFF26b426_gOHM.sol
| 4,763 | 18,841 |
// 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("FANTASIA", "FANTASIA", 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);
}
}
| 329,495 | 14,207 |
1e0969a9dd6d05d0ec5399a63d30a81db102b2f5b7d5e27e403c52770739492e
| 27,428 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/31/3116F15301F62077c5593436Eb7aF3ae6bd6006c_Noonercoin.sol
| 5,995 | 23,116 |
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 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 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;
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) 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;
}
uint256 nowTime = now;
uint256 totalOccurences = getTotalPresentOcuurences();
if(totalOccurences != 120) {
if(nowTime-weekStartTime >= 720){
popRandomVariable();
weekStartTime=now;
}
}
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = now;
uint256 timeDiff = lastMintingTime - startTime;
if(timeDiff >= _cycleTime){
//wei amount of >.5 to be added in adminAccount
if(noonerwei[add] >= (10**18/2)) {
noonercoin[add] += 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;
}
}
//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/720;
if(totalPicks >= estimatePicks){
picks = 0;
}
else {
picks = estimatePicks - totalPicks;
for(uint256 i = 0; i < picks; i++){
popRandomVariable();
}
}
}
}
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);
noonerwei[adminAddress] = 0;
totalWeiBurned = totalWeiBurned + weiToBurned;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = _fundersAmount + weiAmountAdded + (remainingWei/10**18);
previousCyclesTotalWei = remainingWei - (noonercoin[adminAddress] - _fundersAmount - weiAmountAdded) * 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; //admin bal
adminBalanceinWei = noonerwei[add]; //admin bal wei
estimatedMintedToken = (previousCyclesTotalTokens - weiAmountAdded) + 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);
}
}
| 98,352 | 14,208 |
81a0a14097b04df338d2f9c37f509c241416e44493d1298283aa2f482bddd593
| 32,013 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/unlimitedCompilerVersions/0x29fd30b0db31825b622d14109213a9015a4fb92b_unlimitedCompilerVersions.sol
| 3,380 | 13,090 |
pragma solidity ^0.6.12; //inject UNLIMITED COMPILER VERSIONS
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);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract 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 SeoulCityToken is ERC20("SEOUL.CITY.finance", "SEOUL"), Ownable {
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
}
| 278,227 | 14,209 |
2450fb36635204a678c214a2f2570951d48bc53fba8335575dcb2cd256a2e163
| 23,858 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
scraping/data/source/uniswap-v2.sol
| 4,143 | 15,670 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Uni {
/// @notice EIP-20 token name for this token
string public constant name = "Uniswap";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "UNI";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 1_000_000_000e18; // 1 billion Uni
/// @notice Address which may mint new tokens
address public minter;
/// @notice The timestamp after which minting may occur
uint public mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 public constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 public constant mintCap = 2;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when the minter address is changed
event MinterChanged(address minter, address newMinter);
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account, address minter_, uint mintingAllowedAfter_) public {
require(mintingAllowedAfter_ >= block.timestamp, "Uni::constructor: minting can only begin after deployment");
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
minter = minter_;
emit MinterChanged(address(0), minter);
mintingAllowedAfter = mintingAllowedAfter_;
}
function setMinter(address minter_) external {
require(msg.sender == minter, "Uni::setMinter: only the minter can change the minter address");
emit MinterChanged(minter, minter_);
minter = minter_;
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "Uni::mint: only the minter can mint");
require(block.timestamp >= mintingAllowedAfter, "Uni::mint: minting not allowed yet");
require(dst != address(0), "Uni::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);
// mint the amount
uint96 amount = safe96(rawAmount, "Uni::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "Uni::mint: exceeded mint cap");
totalSupply = safe96(SafeMath.add(totalSupply, amount), "Uni::mint: totalSupply exceeds 96 bits");
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "Uni::mint: transfer amount overflows");
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Uni::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, "Uni::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Uni::permit: invalid signature");
require(signatory == owner, "Uni::permit: unauthorized");
require(now <= deadline, "Uni::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, "Uni::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, "Uni::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Uni::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), "Uni::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Uni::delegateBySig: invalid nonce");
require(now <= expiry, "Uni::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, "Uni::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), "Uni::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Uni::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Uni::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Uni::_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, "Uni::_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, "Uni::_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, "Uni::_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;
}
}
| 344,849 | 14,210 |
653cc2ccf3239acf16175bc6280dd6f5c6887cfa8842dbf65c31fa3910817339
| 27,277 |
.sol
|
Solidity
| false |
379749889
|
fegtoken/fegtoken
|
9d688ffd4ccc19c3a3ccec3103b21ee089a26ffe
|
FEG Wrapped/ETH.sol
| 4,795 | 17,772 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
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(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
// File: openzeppelin-solidity\contracts\token\ERC20\IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: openzeppelin-solidity\contracts\utils\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");
}
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 fETH is IERC20 {
using Address for address;
enum TxType { FromExcluded, ToExcluded, BothExcluded, Standard }
mapping (address => uint256) private rBnbBalance;
mapping (address => uint256) private tBnbBalance;
mapping (address => mapping (address => uint256)) private _allowances;
EnumerableSet.AddressSet excluded;
uint256 private tBnbSupply;
uint256 private rBnbSupply;
uint256 private feesAccrued;
string private _name = 'FEG Wrapped ETH';
string private _symbol = 'fETH';
uint8 private _decimals = 18;
address private op;
address private op2;
event Deposit(address indexed dst, uint amount);
event Withdrawal(address indexed src, uint amount);
receive() external payable {
deposit();
}
constructor () {
op = address(0x4c9BC793716e8dC05d1F48D8cA8f84318Ec3043C);
op2 = op;
EnumerableSet.add(excluded, address(0)); // stablity - zen.
emit Transfer(address(0), msg.sender, 0);
}
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 tBnbSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (EnumerableSet.contains(excluded, account)) return tBnbBalance[account];
(uint256 r, uint256 t) = currentSupply();
return (rBnbBalance[account] * t) / r;
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(msg.sender, 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(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender] - subtractedValue);
return true;
}
function isExcluded(address account) public view returns (bool) {
return EnumerableSet.contains(excluded, account);
}
function totalFees() public view returns (uint256) {
return feesAccrued;
}
function deposit() public payable {
require(msg.value > 0, "can't deposit nothing");
(uint256 r, uint256 t) = currentSupply();
tBnbSupply += msg.value;
uint256 fee = msg.value / 100;
uint256 df = fee / 10;
uint256 net = fee != 0 ? (msg.value - (fee)) : msg.value;
if(isExcluded(msg.sender)){
tBnbBalance[msg.sender] += (msg.value - fee);
}
feesAccrued += fee;
rBnbBalance[op] += ((df * r) / t);
rBnbSupply += (((net + df) * r) / t);
rBnbBalance[msg.sender] += ((net * r) / t);
emit Deposit(msg.sender, msg.value);
}
function withdraw(uint amt) public {
require(balanceOf(msg.sender) >= amt && amt <= totalSupply(), "invalid amt");
(uint256 r, uint256 t) = currentSupply();
uint256 fee = amt / 100;
uint256 wf = fee / 8;
uint256 net = amt - fee;
if(isExcluded(msg.sender)) {
tBnbBalance[msg.sender] -= amt;
rBnbBalance[msg.sender] -= ((amt * r) / t);
} else {
rBnbBalance[msg.sender] -= ((amt * r) / t);
}
tBnbSupply -= (net + wf);
rBnbSupply -= (((net + wf) * r) / t);
rBnbBalance[op] += ((wf * r) / t);
feesAccrued += wf;
payable(msg.sender).transfer(net);
emit Withdrawal(msg.sender, net);
}
function rBnbToEveryone(uint256 amt) public {
require(!isExcluded(msg.sender), "not allowed");
(uint256 r, uint256 t) = currentSupply();
rBnbBalance[msg.sender] -= ((amt * r) / t);
rBnbSupply -= ((amt * r) / t);
feesAccrued += amt;
}
function excludeFromFees(address account) external {
require(msg.sender == op2, "op only");
require(!EnumerableSet.contains(excluded, account), "address excluded");
if(rBnbBalance[account] > 0) {
(uint256 r, uint256 t) = currentSupply();
tBnbBalance[account] = (rBnbBalance[account] * (t)) / (r);
}
EnumerableSet.add(excluded, account);
}
function includeInFees(address account) external {
require(msg.sender == op2, "op only");
require(EnumerableSet.contains(excluded, account), "address excluded");
tBnbBalance[account] = 0;
EnumerableSet.remove(excluded, account);
}
function tBnbFromrBnb(uint256 rBnbAmount) external view returns (uint256) {
(uint256 r, uint256 t) = currentSupply();
return (rBnbAmount * t) / r;
}
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 getTtype(address sender, address recipient) internal view returns (TxType t) {
bool isSenderExcluded = EnumerableSet.contains(excluded, sender);
bool isRecipientExcluded = EnumerableSet.contains(excluded, recipient);
if (isSenderExcluded && !isRecipientExcluded) {
t = TxType.FromExcluded;
} else if (!isSenderExcluded && isRecipientExcluded) {
t = TxType.ToExcluded;
} else if (!isSenderExcluded && !isRecipientExcluded) {
t = TxType.Standard;
} else if (isSenderExcluded && isRecipientExcluded) {
t = TxType.BothExcluded;
} else {
t = TxType.Standard;
}
return t;
}
function _transfer(address sender, address recipient, uint256 amt) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amt > 0, "Transfer amt must be greater than zero");
(uint256 r, uint256 t) = currentSupply();
uint256 fee = amt / 100;
TxType tt = getTtype(sender, recipient);
if (tt == TxType.ToExcluded) {
rBnbBalance[sender] -= ((amt * r) / t);
tBnbBalance[recipient] += (amt - fee);
rBnbBalance[recipient] += (((amt - fee) * r) / t);
} else if (tt == TxType.FromExcluded) {
tBnbBalance[sender] -= (amt);
rBnbBalance[sender] -= ((amt * r) / t);
rBnbBalance[recipient] += (((amt - fee) * r) / t);
} else if (tt == TxType.BothExcluded) {
tBnbBalance[sender] -= (amt);
rBnbBalance[sender] -= ((amt * r) / t);
tBnbBalance[recipient] += (amt - fee);
rBnbBalance[recipient] += (((amt - fee) * r) / t);
} else {
rBnbBalance[sender] -= ((amt * r) / t);
rBnbBalance[recipient] += (((amt - fee) * r) / t);
}
rBnbSupply -= ((fee * r) / t);
feesAccrued += fee;
emit Transfer(sender, recipient, amt - fee);
}
function currentSupply() public view returns(uint256, uint256) {
if(rBnbSupply == 0 || tBnbSupply == 0) return (1000000000, 1);
uint256 rSupply = rBnbSupply;
uint256 tSupply = tBnbSupply;
for (uint256 i = 0; i < EnumerableSet.length(excluded); i++) {
if (rBnbBalance[EnumerableSet.at(excluded, i)] > rSupply || tBnbBalance[EnumerableSet.at(excluded, i)] > tSupply) return (rBnbSupply, tBnbSupply);
rSupply -= (rBnbBalance[EnumerableSet.at(excluded, i)]);
tSupply -= (tBnbBalance[EnumerableSet.at(excluded, i)]);
}
if (rSupply < rBnbSupply / tBnbSupply) return (rBnbSupply, tBnbSupply);
return (rSupply, tSupply);
}
function setOp(address opper, address opper2) external {
require(msg.sender == op, "only op can call");
op = opper;
op2 = opper2;
}
}
| 266,647 | 14,211 |
bbb0174c1ff9f419d91364dbeed5a5dc46c2abf5ee8d0072ee17eef9df446954
| 22,544 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TD58Vy9rJuBq7Pout3omzXAXku3v7YYFRq_DiamondDividend.sol
| 3,831 | 15,758 |
//SourceUnit: diamondDividend.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 getAvailableDiamondRake() external returns (uint256);
function requestDiamondRakePayment() external returns(bool);
}
//
//--------------------- DIAMOND CONTRACT INTERFACE ---------------------//
//
interface InterfaceDIAMOND {
function frozenDiamondsGlobal() external returns (uint256);
function usersDiamondFrozen(address user) external returns(uint256);
function transfer(address to, uint256 amount) external returns(bool);
function frozenAccount(address user) external returns(bool);
}
//
//------------------ 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, 'caller must be owner');
_;
}
modifier onlySigner {
require(msg.sender == signer, 'caller must be 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, 'caller must be new owner');
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
//
//--------------------- DIAMOND DIVIDEND CODE STARTS HERE --------------------//
//
contract DiamondDividend is owned {
// Public variables of the token
using SafeMath for uint256;
address public voucherContractAddress;
address public diamondContractAddress;
bool public globalHalt;
uint256 public dividendAccumulated;
uint256 public dividendRemainder;
uint256 public divPercentageSUN = 100000000; //100% of dividend distributed
uint256 public diamondsFrozenAtDivDistribution; //this tracks current total frozen token when dividend is distributed
uint256 public totalDividendsPaidNumber; //total number of dividends distributed. Mainly used with diamondsFrozenAtDivDistribution
uint256 public dividendPaidLastTime;
uint256 public divPaidAllTimeTrx; //tracks total number of div paid in trx
uint256 public blacklistedDiamondAtDivDistribution; //incremental value of globalBlacklistedDiamonds at div distribution
// This creates a mapping with all data storage
mapping (address => bool) public whitelistCaller;
address[] public whitelistCallerArray;
mapping (address => uint256) internal whitelistCallerArrayIndex;
//dividend trackers
mapping (address => uint256) public previousDivAmountWithdrawal; //keeps track of dividend pool amount for user => token at time of div withdrawal
mapping(address => uint256) public totalFrozenDiamondTracker; //tracks totalFrozen diamonds at the time of user freeze token
mapping(address => uint256) public noOfDivPaidAfterFreeze; //tracks number of dividend distribution attempted after user froze
mapping(address => uint256) public blacklistedDiamondTracker; //tracks blacklisted diamond frozen incremental.
mapping(address => uint256) public blacklistedDiamondIndividual;
uint256 public globalBlacklistedDiamonds;
mapping (address => bool) public frozenAccount;
//DividendPaid by admin
event DividendPaidTRX(uint256 indexed totalDividendPaidTRX);
//user withdraw dividend
event DividendWithdrawTRX(address indexed user, uint256 indexed tokenID, uint256 indexed amount);
// This generates a public event for frozen (blacklisting) accounts
event FrozenAccounts(address indexed target, bool frozen, uint256 frozenDiamonds);
constructor() public {
dividendPaidLastTime = now;
}
function () payable external {}
function getDividendPotential() public view returns(uint256){
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableDiamondRake();
if(amount > 0){
totalDividend += amount;
}
}
if(totalDividend > 0 || dividendAccumulated > 0){
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
uint256 newAmount = totalDividend * divPercentageSUN / 100 / 1000000;
return newAmount + dividendAccumulated;
}
//by default it returns zero
}
function distributeMainDividend() public onlySigner returns(string, uint256, uint256, uint256){
uint256 frozenDiamondsGlobal = InterfaceDIAMOND(diamondContractAddress).frozenDiamondsGlobal();
require(frozenDiamondsGlobal > 0, 'none has frozen diamonds');
require(!globalHalt, 'Global Halt is on');
//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(dividendPaidLastTime + 604800 < now, 'You need to wait 7 days to Do This');
}
//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).getAvailableDiamondRake();
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).requestDiamondRakePayment(), 'could not transfer trx');
}
}
uint256 dividendAccumulatedLocal = dividendAccumulated;
if(totalDividend > 0 || dividendAccumulatedLocal > 0){
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
uint256 newAmount = totalDividend * divPercentageSUN / 100 / 1000000;
//if dividend % is less than 100%, then track that remainder in another variable
if(divPercentageSUN < 100000000){
dividendRemainder += totalDividend * (100000000 - divPercentageSUN) / 100 / 1000000;
}
uint256 payableAmount = newAmount + dividendAccumulatedLocal;
divPaidAllTimeTrx += payableAmount;
diamondsFrozenAtDivDistribution += frozenDiamondsGlobal;
totalDividendsPaidNumber++;
blacklistedDiamondAtDivDistribution += globalBlacklistedDiamonds;
dividendPaidLastTime = now;
dividendAccumulated = 0;
emit DividendPaidTRX(payableAmount);
return ("Distro Success: (1) Total Fetched (2) Accumulated Dividend (3) Final Payable amount:", totalDividend, dividendAccumulatedLocal, payableAmount);
}
}
function reInvestDividendRemainder() public payable onlyOwner returns(string){
require(dividendRemainder > 0 || msg.value > 0, 'Invalid amount');
require(!globalHalt, 'Global Halt is on');
dividendAccumulated += dividendRemainder + msg.value;
dividendRemainder=0;
return "dividendRemainder is sent to div pool";
}
function userConfirmedDividendTRX(address user) public view returns(uint256){
if(! InterfaceDIAMOND(diamondContractAddress).frozenAccount(user))
{
//if there are more dividend distribution after user has frozen token
uint256 previousDivAmountWithdrawalLocal = previousDivAmountWithdrawal[user];
uint256 usersDiamondFrozen = InterfaceDIAMOND(diamondContractAddress).usersDiamondFrozen(user);
if(divPaidAllTimeTrx > previousDivAmountWithdrawalLocal && usersDiamondFrozen > 0){
//finding all the subsequent dividends distributed by admin
//all three below trackers can never be zero due to above condition
uint256 blacklistedDiamonds = blacklistedDiamondAtDivDistribution - blacklistedDiamondTracker[user];
uint256 newDividendPoolAmount = divPaidAllTimeTrx - previousDivAmountWithdrawalLocal;
uint256 totalFrozenShares = diamondsFrozenAtDivDistribution - totalFrozenDiamondTracker[user];
uint256 totalNoOfDivPaid = totalDividendsPaidNumber - noOfDivPaidAfterFreeze[user];
//first calculating user share percentage = user freeze tokens * 100 / total frozen tokens
//the reason for the number 1000000, is to have sharePercentage variable have more decimals.
uint256 sharePercentage = usersDiamondFrozen * 100 * 1000000 / (totalFrozenShares / totalNoOfDivPaid) ;
sharePercentage += sharePercentage * (blacklistedDiamonds * 1000000 / usersDiamondFrozen) / 1000000;
//now calculating final trx amount from (available dividend pool * share percentage / 100)
if(newDividendPoolAmount * sharePercentage > 0){
return newDividendPoolAmount * sharePercentage / 100 / 1000000;
}
}
}
else
{
return 0;
}
//by default it will return zero
}
function withdrawDividendsEverythingInternal(address user) internal returns(bool){
//TRX withdraw
uint256 outstandingDivTRX = userConfirmedDividendTRX(user);
if(outstandingDivTRX > 0){
user.transfer(outstandingDivTRX);
emit DividendWithdrawTRX(user, 0, outstandingDivTRX);
}
return true;
}
function withdrawDividendsEverything() public returns(bool){
require(! InterfaceDIAMOND(diamondContractAddress).frozenAccount(user),"you are blacklisted");
require(!globalHalt, 'Global Halt is on');
//tx.origin is because it will take original caller even if user is calling via another contract.
address user = tx.origin;
//second param as true, meaning it will update the dividend tracker
require(withdrawDividendsEverythingInternal(user), 'withdraw dividend everything function did not work');
//this will track the total frozen token at the time of freeze
//which will be used in calculating share percentage of div pool
totalFrozenDiamondTracker[user] = diamondsFrozenAtDivDistribution;
//this will track all the dividend distribution attempts.
noOfDivPaidAfterFreeze[user] = totalDividendsPaidNumber;
//TRX withdraw
previousDivAmountWithdrawal[user] = divPaidAllTimeTrx;
//updates the value of globalBlacklistedDiamonds when this action
blacklistedDiamondTracker[user] = globalBlacklistedDiamonds;
return true;
}
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 updateContractAddresses(address _voucherContract, address _diamondContract) public onlyOwner returns(string){
voucherContractAddress = _voucherContract;
diamondContractAddress = _diamondContract;
return "voucher and diamond conract address updated successfully";
}
function manualWithdrawTokens(address token, uint256 tokenAmount) public onlyOwner returns(string){
// no need for overflow checking as that will be done in transfer function
InterfaceDIAMOND(token).transfer(owner, tokenAmount);
return "Tokens withdrawn to owner wallet";
}
function manualWithdrawTRX(uint256 amount) public onlyOwner returns(string){
owner.transfer(amount);
return "TRX 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 freezeUnfreezeAccount(address userAddress) onlyOwner public returns (string)
{
bool freeze = InterfaceDIAMOND(diamondContractAddress).frozenAccount(userAddress);
uint256 frozenDiamonds = InterfaceDIAMOND(diamondContractAddress).usersDiamondFrozen(userAddress);
if (freeze && !frozenAccount[userAddress])
{
blacklistedDiamondIndividual[userAddress] = frozenDiamonds;
globalBlacklistedDiamonds += frozenDiamonds;
frozenAccount[userAddress] = true;
emit FrozenAccounts(userAddress, freeze , frozenDiamonds);
return "Accounts frozen successfully";
}
else if (!freeze && frozenAccount[userAddress])
{
blacklistedDiamondIndividual[userAddress] = 0;
globalBlacklistedDiamonds -= frozenDiamonds;
frozenAccount[userAddress] = false;
emit FrozenAccounts(userAddress, freeze, frozenDiamonds);
return "Accounts un-frozen successfully";
}
return "Nothing happened as either duplicate transaction or conditions dont met";
}
}
| 296,829 | 14,212 |
b6b41887fe5df59c181c192fc37ee33d1b15740912004fd3a4caf4cbc90038fa
| 33,093 |
.sol
|
Solidity
| false |
366468716
|
idexo/ido-contracts
|
4c4f94bee4c80579c1cfb53a0c09ada5bb265aad
|
flattened/MultipleVotingMirror.sol
| 4,510 | 16,434 |
pragma solidity ^0.8.0;
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
interface IAccessControl {
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) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// OpenZeppelin Contracts v4.4.1 (access/AccessControl.sol)
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role, address account) internal view {
if (!hasRole(role, account)) {
revert(string(abi.encodePacked("AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32))));
}
}
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
interface IStakeMirrorNFT is IERC721 {
function getStakeInfo(uint256 stakeId)
external
returns (uint256, uint256, uint256);
function getStakeTokenIds(address account)
external
returns (uint256[] memory);
function isHolder(address account) external view returns (bool);
function stakes(uint256 id) external view returns (uint256 amount, uint256 multiplier, uint256 depositedAt);
function stakerIds(address account, uint256 id) external view returns (uint256);
function addOperator(address account) external;
function removeOperator(address account) external;
function checkOperator(address account) external view returns (bool);
}
contract MultipleVotingMirror is Ownable, AccessControl {
struct Poll {
uint256 startTime; // poll start timestamp
uint256 endTime; // poll end timestamp
uint8 minimumStakeTimeInDays; // number of days that implies how long stakers should remain staked in stake pool to vote
uint8 winningOptionId; // poll result, starts from 1
string description; // poll description
string[] options; // poll option string, first option string is default empty ('')
address creator; // poll creator address
address[] voters; // poll voter address array
}
struct Voter {
uint8 optionId; // vote option index, `0` implies he/she did not cast vote
uint256 weight; // voter's voting weight (derived from stake pool)
}
// poll id => poll info
mapping(uint256 => Poll) private _polls;
// poll id => voter address => voter info
mapping(uint256 => mapping(address => Voter)) private _voters;
// poll id => option id => vote cast number
mapping(uint256 => mapping(uint8 => uint256)) private _votes;
// stake pool address => status
mapping(address => bool) public isStakePool;
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
uint256 public pollIds;
IStakeMirrorNFT[] public stakePools;
event VoteCasted(address indexed voter, uint256 pollID, uint8 optionId, uint256 weight);
event PollCreated(address indexed creator, uint256 pollID);
constructor(address[] memory stakePools_) {
for (uint256 i = 0; i < stakePools_.length; i++) {
if (stakePools_[i] != address(0)) {
stakePools.push(IStakeMirrorNFT(stakePools_[i]));
isStakePool[stakePools_[i]] = true;
}
}
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setupRole(OPERATOR_ROLE, msg.sender);
}
modifier onlyAdmin() {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "CALLER_NO_ADMIN_ROLE");
_;
}
modifier onlyOperator() {
require(hasRole(OPERATOR_ROLE, msg.sender), "CALLER_NO_OPERATOR_ROLE");
_;
}
function addOperator(address account) public onlyAdmin {
grantRole(OPERATOR_ROLE, account);
}
function removeOperator(address account) public onlyAdmin {
revokeRole(OPERATOR_ROLE, account);
}
function checkOperator(address account) public view returns (bool) {
return hasRole(OPERATOR_ROLE, account);
}
function addStakePool(address _sPool) external onlyOperator {
require(_sPool != address(0), "STAKE_POOL_ADDRESS_INVALID");
require(_isContract(_sPool), "STAKE_POOL_NOT_CONTRACT");
require(!isStakePool[_sPool], "STAKE_POOL_ADDRESS_ALREADY_FOUND");
stakePools.push(IStakeMirrorNFT(_sPool));
isStakePool[_sPool] = true;
}
function removeStakePool(address _sPool) external onlyOperator {
require(isStakePool[_sPool], "STAKE_POOL_ADDRESS_NOT_FOUND");
uint256 len = stakePools.length;
for (uint256 i = 0; i < len; i++) {
if (address(stakePools[i]) == _sPool) {
if (i != len - 1) {
stakePools[i] = stakePools[len - 1];
}
stakePools.pop();
break;
}
}
isStakePool[_sPool] = false;
}
modifier validPoll(uint256 _pollId) {
require(_pollId > 0 && _pollId <= pollIds, "POLL_ID_INVALID");
_;
}
function getPollInfo(uint256 _pollId) public view validPoll(_pollId)
returns (string memory,
string[] memory,
uint256,
uint256,
uint8,
address,
address[] memory)
{
Poll memory poll = _polls[_pollId];
return (poll.description,
poll.options,
poll.startTime,
poll.endTime,
poll.minimumStakeTimeInDays,
poll.creator,
poll.voters);
}
function getPollVotingInfo(uint256 _pollId) public view validPoll(_pollId) returns (uint256[] memory, uint8) {
Poll memory poll = _polls[_pollId];
require(block.timestamp >= poll.endTime || checkOperator(msg.sender), "POLL_NOT_ENDED__CALLER_NO_OPERATOR");
uint256[] memory votes = new uint256[](poll.options.length);
for (uint8 i = 0; i < votes.length; i++) {
votes[i] = _votes[_pollId][i];
}
return (votes, poll.winningOptionId);
}
function getVoterInfo(uint256 _pollId,
address _voter) public view validPoll(_pollId) returns (uint8, uint256) {
require(block.timestamp >= _polls[_pollId].endTime || checkOperator(msg.sender), "POLL_NOT_ENDED__CALLER_NO_OPERATOR");
Voter memory voter = _voters[_pollId][_voter];
return (voter.optionId, voter.weight);
}
function createPoll(string memory _description,
string[] memory _options,
uint256 _startTime,
uint256 _endTime,
uint8 _minimumStakeTimeInDays) public onlyOperator returns (uint256) {
require(bytes(_description).length > 0, "DESCRIPTION_INVALID");
require(_options.length > 1, "OPTIONS_INVALID");
require(_startTime >= block.timestamp, "START_TIME_INVALID");
require(_endTime > _startTime, "END_TIME_INVALID");
uint256 newPollId = pollIds + 1;
pollIds = newPollId;
Poll storage poll = _polls[newPollId];
poll.startTime = _startTime;
poll.endTime = _endTime;
poll.minimumStakeTimeInDays = _minimumStakeTimeInDays;
poll.description = _description;
poll.options.push("");
for (uint8 i = 0; i < _options.length; i++) {
poll.options.push(_options[i]);
}
poll.creator = msg.sender;
emit PollCreated(msg.sender, newPollId);
return newPollId;
}
function updatePollTime(uint256 _pollId,
uint256 _startTime,
uint256 _endTime) public onlyOperator validPoll(_pollId) {
Poll storage poll = _polls[_pollId];
uint256 startTime = poll.startTime;
bool started = startTime < block.timestamp;
bool ended = poll.endTime < block.timestamp;
require(!ended, "POLL_ENDED");
if (_startTime >= block.timestamp && !started) {
poll.startTime = _startTime;
startTime = _startTime;
}
if (_endTime >= block.timestamp) {
poll.endTime = _endTime;
}
}
function checkIfVoted(uint256 _pollId,
address _account) public view validPoll(_pollId) returns (bool) {
return _voters[_pollId][_account].optionId != 0;
}
function castVote(uint256 _pollId,
uint8 _optionId) external validPoll(_pollId) {
require(_optionId > 0, "INVALID_VOTE_OPTION_ID");
Poll storage poll = _polls[_pollId];
require(block.timestamp < poll.endTime, "POLL_ENDED");
require(!checkIfVoted(_pollId, msg.sender), "USER_VOTED");
uint256 w = _getWeight(_pollId, msg.sender);
uint256 optionVote = _votes[_pollId][_optionId] + w;
_votes[_pollId][_optionId] = optionVote;
// decide winning option id
if (optionVote > _votes[_pollId][poll.winningOptionId]) {
poll.winningOptionId = _optionId;
}
Voter storage voter = _voters[_pollId][msg.sender];
voter.optionId = _optionId;
voter.weight = w;
emit VoteCasted(msg.sender, _pollId, _optionId, w);
}
function _getWeight(uint256 _pollId,
address _account) private validPoll(_pollId) returns (uint256) {
require(_account != address(0), "ACCOUNT_INVALID");
uint256 w; // total weight
bool oldEnough = true;
Poll memory poll = _polls[_pollId];
require(block.timestamp < poll.endTime, "POLL_ENDED");
for (uint256 i = 0; i < stakePools.length; i++) {
IStakeMirrorNFT sPool = stakePools[i];
uint256[] memory sTokenIds = sPool.getStakeTokenIds(_account);
for (uint256 j = 0; j < sTokenIds.length; j++) {
(uint256 amount, , uint256 depositedAt) = sPool.getStakeInfo(sTokenIds[j]);
if (depositedAt + poll.minimumStakeTimeInDays * 1 days < poll.startTime) {
w += amount;
} else {
oldEnough = false;
}
}
}
require(w > 0, oldEnough ? "NO_VALID_VOTING_NFTS_PRESENT" : "STAKE_NOT_OLD_ENOUGH");
return w;
}
function _isContract(address _account) private view returns (bool) {
uint size;
assembly {
size := extcodesize(_account)
}
return size > 0;
}
}
| 16,966 | 14,213 |
ef37be39f4cc5c25d533aaba4ab89f1df8b844ca77af6aeb8c358d011c1d7462
| 21,596 |
.sol
|
Solidity
| false |
600295047
|
ZhangZhuoSJTU/Web3Bugs
|
1243d0b5dba9f455b7034394cd0ea01fcdc8140e
|
contracts/124/index-coop-notional-trade-module/external/contracts/compound/PriceOracle.sol
| 3,688 | 14,849 |
pragma solidity ^0.4.24;
contract CompoundPriceOracle is Exponential {
bool public paused;
uint public constant numBlocksPerPeriod = 240; // approximately 1 hour: 60 seconds/minute * 60 minutes/hour * 1 block/15 seconds
uint public constant maxSwingMantissa = (10 ** 17); // 0.1
mapping(address => DSValue) public readers;
mapping(address => Exp) public _assetPrices;
constructor(address _poster, address addr0, address reader0, address addr1, address reader1) public {
anchorAdmin = msg.sender;
poster = _poster;
maxSwing = Exp({mantissa : maxSwingMantissa});
// Make sure the assets are zero or different
assert(addr0 == address(0) || (addr0 != addr1));
if (addr0 != address(0)) {
assert(reader0 != address(0));
readers[addr0] = DSValue(reader0);
} else {
assert(reader0 == address(0));
}
if (addr1 != address(0)) {
assert(reader1 != address(0));
readers[addr1] = DSValue(reader1);
} else {
assert(reader1 == address(0));
}
}
function() payable public {
revert();
}
enum OracleError {
NO_ERROR,
UNAUTHORIZED,
FAILED_TO_SET_PRICE
}
enum OracleFailureInfo {
ACCEPT_ANCHOR_ADMIN_PENDING_ANCHOR_ADMIN_CHECK,
SET_PAUSED_OWNER_CHECK,
SET_PENDING_ANCHOR_ADMIN_OWNER_CHECK,
SET_PENDING_ANCHOR_PERMISSION_CHECK,
SET_PRICE_CALCULATE_SWING,
SET_PRICE_CAP_TO_MAX,
SET_PRICE_MAX_SWING_CHECK,
SET_PRICE_NO_ANCHOR_PRICE_OR_INITIAL_PRICE_ZERO,
SET_PRICE_PERMISSION_CHECK,
SET_PRICE_ZERO_PRICE,
SET_PRICES_PARAM_VALIDATION,
SET_PRICE_IS_READER_ASSET
}
event OracleFailure(address msgSender, address asset, uint error, uint info, uint detail);
function failOracle(address asset, OracleError err, OracleFailureInfo info) internal returns (uint) {
emit OracleFailure(msg.sender, asset, uint(err), uint(info), 0);
return uint(err);
}
function failOracleWithDetails(address asset, OracleError err, OracleFailureInfo info, uint details) internal returns (uint) {
emit OracleFailure(msg.sender, asset, uint(err), uint(info), details);
return uint(err);
}
address public anchorAdmin;
address public pendingAnchorAdmin;
address public poster;
Exp public maxSwing;
struct Anchor {
// floor(block.number / numBlocksPerPeriod) + 1
uint period;
// Price in ETH, scaled by 10**18
uint priceMantissa;
}
mapping(address => Anchor) public anchors;
mapping(address => uint) public pendingAnchors;
event NewPendingAnchor(address anchorAdmin, address asset, uint oldScaledPrice, uint newScaledPrice);
function _setPendingAnchor(address asset, uint newScaledPrice) public returns (uint) {
if (msg.sender != anchorAdmin) {
return failOracle(asset, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PENDING_ANCHOR_PERMISSION_CHECK);
}
uint oldScaledPrice = pendingAnchors[asset];
pendingAnchors[asset] = newScaledPrice;
emit NewPendingAnchor(msg.sender, asset, oldScaledPrice, newScaledPrice);
return uint(OracleError.NO_ERROR);
}
event PricePosted(address asset, uint previousPriceMantissa, uint requestedPriceMantissa, uint newPriceMantissa);
event CappedPricePosted(address asset, uint requestedPriceMantissa, uint anchorPriceMantissa, uint cappedPriceMantissa);
event SetPaused(bool newState);
event NewPendingAnchorAdmin(address oldPendingAnchorAdmin, address newPendingAnchorAdmin);
event NewAnchorAdmin(address oldAnchorAdmin, address newAnchorAdmin);
function _setPaused(bool requestedState) public returns (uint) {
// Check caller = anchorAdmin
if (msg.sender != anchorAdmin) {
return failOracle(0, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PAUSED_OWNER_CHECK);
}
paused = requestedState;
emit SetPaused(requestedState);
return uint(Error.NO_ERROR);
}
function _setPendingAnchorAdmin(address newPendingAnchorAdmin) public returns (uint) {
// Check caller = anchorAdmin
if (msg.sender != anchorAdmin) {
return failOracle(0, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PENDING_ANCHOR_ADMIN_OWNER_CHECK);
}
// save current value, if any, for inclusion in log
address oldPendingAnchorAdmin = pendingAnchorAdmin;
// Store pendingAdmin = newPendingAdmin
pendingAnchorAdmin = newPendingAnchorAdmin;
emit NewPendingAnchorAdmin(oldPendingAnchorAdmin, newPendingAnchorAdmin);
return uint(Error.NO_ERROR);
}
function _acceptAnchorAdmin() public returns (uint) {
// Check caller = pendingAnchorAdmin
// msg.sender can't be zero
if (msg.sender != pendingAnchorAdmin) {
return failOracle(0, OracleError.UNAUTHORIZED, OracleFailureInfo.ACCEPT_ANCHOR_ADMIN_PENDING_ANCHOR_ADMIN_CHECK);
}
// Save current value for inclusion in log
address oldAnchorAdmin = anchorAdmin;
// Store admin = pendingAnchorAdmin
anchorAdmin = pendingAnchorAdmin;
// Clear the pending value
pendingAnchorAdmin = 0;
emit NewAnchorAdmin(oldAnchorAdmin, msg.sender);
return uint(Error.NO_ERROR);
}
function assetPrices(address asset) public view returns (uint) {
// Note: zero is treated by the money market as an invalid
// price and will cease operations with that asset
// when zero.
//
// We get the price as:
//
// 1. If the contract is paused, return 0.
// 2. If the asset is a reader asset:
// a. If the reader has a value set, invert it and return.
// b. Else, return 0.
// 3. Return price in `_assetPrices`, which may be zero.
if (paused) {
return 0;
} else {
if (readers[asset] != address(0)) {
(bytes32 readValue, bool foundValue) = readers[asset].peek();
if (foundValue) {
(Error error, Exp memory invertedVal) = getExp(mantissaOne, uint256(readValue));
if (error != Error.NO_ERROR) {
return 0;
}
return invertedVal.mantissa;
} else {
return 0;
}
} else {
return _assetPrices[asset].mantissa;
}
}
}
function getPrice(address asset) public view returns (uint) {
return assetPrices(asset);
}
struct SetPriceLocalVars {
Exp price;
Exp swing;
Exp anchorPrice;
uint anchorPeriod;
uint currentPeriod;
bool priceCapped;
uint cappingAnchorPriceMantissa;
uint pendingAnchorMantissa;
}
function setPrice(address asset, uint requestedPriceMantissa) public returns (uint) {
// Fail when msg.sender is not poster
if (msg.sender != poster) {
return failOracle(asset, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PRICE_PERMISSION_CHECK);
}
return setPriceInternal(asset, requestedPriceMantissa);
}
function setPriceInternal(address asset, uint requestedPriceMantissa) internal returns (uint) {
// re-used for intermediate errors
Error err;
SetPriceLocalVars memory localVars;
// (It can be a problem in tests with low block numbers.)
localVars.currentPeriod = (block.number / numBlocksPerPeriod) + 1;
localVars.pendingAnchorMantissa = pendingAnchors[asset];
localVars.price = Exp({mantissa : requestedPriceMantissa});
if (readers[asset] != address(0)) {
return failOracle(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_IS_READER_ASSET);
}
if (localVars.pendingAnchorMantissa != 0) {
// let's explicitly set to 0 rather than relying on default of declaration
localVars.anchorPeriod = 0;
localVars.anchorPrice = Exp({mantissa : localVars.pendingAnchorMantissa});
// Verify movement is within max swing of pending anchor (currently: 10%)
(err, localVars.swing) = calculateSwing(localVars.anchorPrice, localVars.price);
if (err != Error.NO_ERROR) {
return failOracleWithDetails(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_CALCULATE_SWING, uint(err));
}
// Fail when swing > maxSwing
if (greaterThanExp(localVars.swing, maxSwing)) {
return failOracleWithDetails(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_MAX_SWING_CHECK, localVars.swing.mantissa);
}
} else {
localVars.anchorPeriod = anchors[asset].period;
localVars.anchorPrice = Exp({mantissa : anchors[asset].priceMantissa});
if (localVars.anchorPeriod != 0) {
(err, localVars.priceCapped, localVars.price) = capToMax(localVars.anchorPrice, localVars.price);
if (err != Error.NO_ERROR) {
return failOracleWithDetails(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_CAP_TO_MAX, uint(err));
}
if (localVars.priceCapped) {
// save for use in log
localVars.cappingAnchorPriceMantissa = localVars.anchorPrice.mantissa;
}
} else {
localVars.anchorPrice = Exp({mantissa : requestedPriceMantissa});
}
}
// Fail if anchorPrice or price is zero.
// zero anchor represents an unexpected situation likely due to a problem in this contract
// zero price is more likely as the result of bad input from the caller of this function
if (isZeroExp(localVars.anchorPrice)) {
return failOracle(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_NO_ANCHOR_PRICE_OR_INITIAL_PRICE_ZERO);
}
if (isZeroExp(localVars.price)) {
return failOracle(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_ZERO_PRICE);
}
// BEGIN SIDE EFFECTS
// Set pendingAnchor = Nothing
// Pending anchor is only used once.
if (pendingAnchors[asset] != 0) {
pendingAnchors[asset] = 0;
}
// If currentPeriod > anchorPeriod:
// Set anchors[asset] = (currentPeriod, price)
if (localVars.currentPeriod > localVars.anchorPeriod) {
anchors[asset] = Anchor({period : localVars.currentPeriod, priceMantissa : localVars.price.mantissa});
}
uint previousPrice = _assetPrices[asset].mantissa;
setPriceStorageInternal(asset, localVars.price.mantissa);
emit PricePosted(asset, previousPrice, requestedPriceMantissa, localVars.price.mantissa);
if (localVars.priceCapped) {
// We have set a capped price. Log it so we can detect the situation and investigate.
emit CappedPricePosted(asset, requestedPriceMantissa, localVars.cappingAnchorPriceMantissa, localVars.price.mantissa);
}
return uint(OracleError.NO_ERROR);
}
// As a function to allow harness overrides
function setPriceStorageInternal(address asset, uint256 priceMantissa) internal {
_assetPrices[asset] = Exp({mantissa: priceMantissa});
}
// abs(price - anchorPrice) / anchorPrice
function calculateSwing(Exp memory anchorPrice, Exp memory price) pure internal returns (Error, Exp memory) {
Exp memory numerator;
Error err;
if (greaterThanExp(anchorPrice, price)) {
(err, numerator) = subExp(anchorPrice, price);
// can't underflow
assert(err == Error.NO_ERROR);
} else {
(err, numerator) = subExp(price, anchorPrice);
// Given greaterThan check above, price >= anchorPrice so can't underflow.
assert(err == Error.NO_ERROR);
}
return divExp(numerator, anchorPrice);
}
function capToMax(Exp memory anchorPrice, Exp memory price) view internal returns (Error, bool, Exp memory) {
Exp memory one = Exp({mantissa : mantissaOne});
Exp memory onePlusMaxSwing;
Exp memory oneMinusMaxSwing;
Exp memory max;
Exp memory min;
// re-used for intermediate errors
Error err;
(err, onePlusMaxSwing) = addExp(one, maxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa : 0}));
}
// max = anchorPrice * (1 + maxSwing)
(err, max) = mulExp(anchorPrice, onePlusMaxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa : 0}));
}
// If price > anchorPrice * (1 + maxSwing)
// Set price = anchorPrice * (1 + maxSwing)
if (greaterThanExp(price, max)) {
return (Error.NO_ERROR, true, max);
}
(err, oneMinusMaxSwing) = subExp(one, maxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa : 0}));
}
// min = anchorPrice * (1 - maxSwing)
(err, min) = mulExp(anchorPrice, oneMinusMaxSwing);
// We can't overflow here or we would have already overflowed above when calculating `max`
assert(err == Error.NO_ERROR);
// If price < anchorPrice * (1 - maxSwing)
// Set price = anchorPrice * (1 - maxSwing)
if (lessThanExp(price, min)) {
return (Error.NO_ERROR, true, min);
}
return (Error.NO_ERROR, false, price);
}
function setPrices(address[] assets, uint[] requestedPriceMantissas) public returns (uint[] memory) {
uint numAssets = assets.length;
uint numPrices = requestedPriceMantissas.length;
uint[] memory result;
// Fail when msg.sender is not poster
if (msg.sender != poster) {
result = new uint[](1);
result[0] = failOracle(0, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PRICE_PERMISSION_CHECK);
return result;
}
if ((numAssets == 0) || (numPrices != numAssets)) {
result = new uint[](1);
result[0] = failOracle(0, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICES_PARAM_VALIDATION);
return result;
}
result = new uint[](numAssets);
for (uint i = 0; i < numAssets; i++) {
result[i] = setPriceInternal(assets[i], requestedPriceMantissas[i]);
}
return result;
}
}
| 272,509 | 14,214 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.